xref: /arkcompiler/runtime_core/static_core/plugins/ets/stdlib/escompat/TypedUArrays.sts

/*
 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Autogenerated file. DO NOT EDIT
package escompat

// NOTE(kprokopenko): placing into std.core.Runtime breaks frontend
native function RuntimeGetPlatformIsLittleEndian(): boolean

const IS_LITTLE_ENDIAN = RuntimeGetPlatformIsLittleEndian()

class Uint8ClampedArrayIteratorKeys implements IterableIterator<number> {
    private length: int = 0
    private idx: int = 0

    constructor(parent: Uint8ClampedArray) {
        this.length = parent.length as int
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<number> {
        if (this.idx < 0 || this.idx >= this.length) {
            return new IteratorResult<number>()
        }
        return new IteratorResult<number>(false, this.idx++ as number)
    }
}

class Uint8ClampedArrayIterator implements IterableIterator<Number> {
    private parent: Uint8ClampedArray
    private idx: int = 0

    constructor(parent: Uint8ClampedArray) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<Number> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<Number>()
        }
        return new IteratorResult<Number>(false, new Number(this.parent.getUnsafe(this.idx++)))
    }
}

class Uint8ClampedArrayIteratorEntries implements IterableIterator<[Number, Number]> {
    private parent: Uint8ClampedArray
    private idx: int = 0

    constructor(parent: Uint8ClampedArray) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<[Number, Number]> {
        return this
    }

    override next(): IteratorResult<[Number, Number]> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<[Number, Number]>()
        }
        return new IteratorResult<[Number, Number]>(
            false,
            [new Number(this.idx), new Number(this.parent.getUnsafe(this.idx++))]
        )
    }
}

/**
 * JS Uint8ClampedArray API-compatible class
 */
export class Uint8ClampedArray implements Iterable<Number>, ArrayLike<Number> {
    public static readonly BYTES_PER_ELEMENT: number = 1

    /** Underlying Buffer */
    public readonly buffer: ArrayBufferLike

    internal readonly byteOffsetInt: int
    internal readonly byteLengthInt: int
    internal readonly lengthInt: int

    /**
     * Creates an empty Uint8ClampedArray.
     */
    public constructor() {
        this(0 as int)
    }

    /**
     * Creates an Uint8ClampedArray with respect to data accessed via Iterable<Number> interface
     */
    public constructor(elements: Iterable<Number>) {
        // NOTE (ikorobkov): dealing with this overload is tricky
        // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
        let arr = Array.from<Number>(elements)
        this.byteLengthInt = arr.length as int * Uint8ClampedArray.BYTES_PER_ELEMENT as int
        this.lengthInt = arr.length as int
        this.buffer = new ArrayBuffer(this.byteLengthInt)
        this.byteOffsetInt = 0
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, Uint8ClampedArray.clamp(arr.$_get(i).intValue()))
        }
    }

    /**
     * Creates an Uint8ClampedArray with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint8ClampedArray
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined, length: Number | undefined) {
        let intByteOffset: int = 0
        if (byteOffset != undefined) {
            intByteOffset = byteOffset.intValue()
            if (intByteOffset < 0) {
                throw new RangeError("Range Error: byteOffset " + intByteOffset + " is outside the bounds of the buffer")
            }
        }
        let intByteLength: int
        if (buf instanceof ArrayBuffer) {
            intByteLength = (buf as ArrayBuffer).getByteLength()
        } else if (buf instanceof SharedArrayBuffer) {
            intByteLength = (buf as SharedArrayBuffer).getByteLength()
        } else {
            throw new Error("unexpected type of ArrayBufferLike")
        }
        intByteLength = intByteLength - intByteOffset
        if (intByteLength < 0) {
            throw new RangeError("Range Error: byteLength " + intByteLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
        }

        let intLength: int
        if (length != undefined) {
            intLength = length.intValue()
            if (intLength > intByteLength / Uint8ClampedArray.BYTES_PER_ELEMENT as int) {
                throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
            }
        } else {
            intLength = intByteLength / Uint8ClampedArray.BYTES_PER_ELEMENT as int
        }
        if (intLength < 0) {
            throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer")
        }
        if (intLength < intByteLength / Uint8ClampedArray.BYTES_PER_ELEMENT as int) {
            intByteLength = intLength * Uint8ClampedArray.BYTES_PER_ELEMENT as int
        }
        this.byteLengthInt = intByteLength
        this.byteOffsetInt = intByteOffset
        this.lengthInt = intLength
        this.buffer = buf
    }

    /**
     * Creates an Uint8ClampedArray with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined) {
        this(buf, byteOffset, undefined)
    }

    /**
     * Creates an Uint8ClampedArray with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint8ClampedArray
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number, length: number) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an Uint8ClampedArray with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an Uint8ClampedArray with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint8ClampedArray
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int, length: int) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an Uint8ClampedArray with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an Uint8ClampedArray with respect to buf.
     *
     * @param buf data initializer
     */
    public constructor(buf: ArrayLike<Number> | ArrayBufferLike) {
        if (buf instanceof ArrayBuffer) {
            this.byteLengthInt = (buf as ArrayBuffer).getByteLength()
            if (this.byteLengthInt % Uint8ClampedArray.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of int as Uint8ClampedArray.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / Uint8ClampedArray.BYTES_PER_ELEMENT as int
            this.buffer = buf as ArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof SharedArrayBuffer) {
            this.byteLengthInt = (buf as SharedArrayBuffer).getByteLength()
            if (this.byteLengthInt % Uint8ClampedArray.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of int as Uint8ClampedArray.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / Uint8ClampedArray.BYTES_PER_ELEMENT as int
            this.buffer = buf as SharedArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof ArrayLike) {
            // NOTE (ikorobkov): dealing with this overload is tricky
            // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
            let arr = Array.from<Number>((buf as ArrayLike<Number>))
            this.byteLengthInt = arr.length as int * Uint8ClampedArray.BYTES_PER_ELEMENT as int
            this.lengthInt = arr.length as int
            this.buffer = new ArrayBuffer(this.byteLengthInt)
            this.byteOffsetInt = 0
            for (let i: int = 0; i < this.lengthInt; ++i) {
                this.setUnsafe(i, Uint8ClampedArray.clamp(arr.$_get(i).intValue()))
            }
        } else {
            throw new Error("unexpected type of buf")
        }
    }

    /**
     * Creates an Uint8ClampedArray with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: int) {
        if (length < 0) {
            throw new RangeError("Range Error: length " + length + " is outside the bounds of the buffer")
        }
        this.lengthInt = length
        this.byteLengthInt = length * Uint8ClampedArray.BYTES_PER_ELEMENT as int
        this.byteOffsetInt = 0
        this.buffer = new ArrayBuffer(this.byteLengthInt)
    }

    /**
     * Creates an Uint8ClampedArray with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: number) {
        this(length as int)
    }

    /**
     * Creates a copy of Uint8ClampedArray.
     *
     * @param other data initializer
     */
    public constructor(other: Uint8ClampedArray) {
        if (other.buffer instanceof ArrayBuffer) {
            this.buffer = (other.buffer as ArrayBuffer).slice(0 as int, other.byteLength as int) as ArrayBuffer
        } else if (other.buffer instanceof SharedArrayBuffer) {
            this.buffer = (other.buffer as SharedArrayBuffer).slice(0 as int, other.byteLength as int) as SharedArrayBuffer
        } else {
            throw new Error("unexpected type of buffer")
        }
        this.byteLengthInt = other.byteLength as int
        this.lengthInt = other.length as int
        this.byteOffsetInt = 0
    }

    /**
     * Creates an Uint8ClampedArray from number[]
     */
    public constructor(numbers: number[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, numbers[i] as int)
        }
    }

    /**
     * Creates an Uint8ClampedArray from int[]
     */
    public constructor(numbers: int[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, numbers[i] as int)
        }
    }

    /**
     * Iteratorable interface implementation
     *
     * @returns iterator over all elements
     */
    public override $_iterator(): IterableIterator<Number> {
         return this.values()
    }

    /**
     * Returns an instance of primitive type at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: number): Number | undefined {
        return this.at(index as int)
    }

    /**
     * Returns an instance of primitive type at passed index if index is correct.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: int): Number | undefined {
        let k: int
        if (index >= 0) {
            k = index
        } else {
            k = this.lengthInt + index
        }
        if (k < 0 || k >= this.lengthInt) {
            return undefined
        }
        return new Number(this.getUnsafe(k))
    }

    /**
     * Returns an instance of number at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public override $_get(index: number): Number {
        return this.$_get(index as int) as Number
    }

    /**
     * Returns an instance of number at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public $_get(i: int): number {
        if (i < 0 || i >= this.lengthInt) {
            throw new RangeError("invalid offset")
        }
        return this.getUnsafe(i) as number
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: number): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: number): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        this.setUnsafeClamp(index, val as int)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: int): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: int): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        this.setUnsafeClamp(index, val)
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: number, end?: number): Uint8ClampedArray {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: number, end?: number): Uint8ClampedArray {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: int, end?: number): Uint8ClampedArray {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end?: number): Uint8ClampedArray {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param insert insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end: int): Uint8ClampedArray {
        let toPos = normalizeIndex(target, this.lengthInt)
        let fromPos = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        let count: int = finalPos - fromPos
        if (count > (this.lengthInt - toPos)) {
            count = this.lengthInt - toPos
        }
        let direction: int = 1
        if ((fromPos < toPos) && (toPos < fromPos + count)) {
            fromPos = fromPos + count - 1
            toPos   = toPos   + count - 1
            direction = -1
        }
        while (count > 0) {
            const value = this.getUnsafe(fromPos)
            this.setUnsafe(toPos, value)
            fromPos = fromPos + direction
            toPos = toPos + direction
            --count
        }
        return this
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of Uint8ClampedArray.
     *
     * @param target insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: number): Uint8ClampedArray {
        return this.copyWithin(target as int)
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of Uint8ClampedArray.
     *
     * @param insert insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: int): Uint8ClampedArray {
        return this.copyWithin(target, 0, this.lengthInt)
    }

    /**
     * Returns an array of key, value pairs for every entry in the Uint8ClampedArray
     *
     * @returns key, value pairs for every entry in the array
     */
    public entries(): IterableIterator<[Number, Number]> {
        return new Uint8ClampedArrayIteratorEntries(this)
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: number, start?: number, end?: number): Uint8ClampedArray {
        this.fill(value as int, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: number, start: int, end?: number): Uint8ClampedArray {
        this.fill(value as int, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: number, start: int, end: number): Uint8ClampedArray {
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: number, start: number, end: int): Uint8ClampedArray {
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: number, start: int, end: int): Uint8ClampedArray {
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: int, start?: number, end?: number): Uint8ClampedArray {
        this.fill(value, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: int, start: int, end?: number): Uint8ClampedArray {
        this.fill(value, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: int, start: int, end: number): Uint8ClampedArray {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: int, start: number, end: int): Uint8ClampedArray {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8ClampedArray with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8ClampedArray
     */
    public fill(value: int, start: int, end: int): Uint8ClampedArray {
        value = Uint8ClampedArray.clamp(value)
        const k = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        for (let i: int = k; i < finalPos; ++i) {
            this.setUnsafe(i, value)
        }
        return this
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: number): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: number): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: int): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: int): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Copies all elements of arr to the current Uint8ClampedArray starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: number[], insertPos1: number): void {
        const insertPos = insertPos1 as int
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: int[]): size of arr is greater than Uint8ClampedArray.length")
        }
        for (let i = 0; i < arr.length; i++) {
            this.setUnsafeClamp(insertPos as int + i as int, arr[i] as int)
        }
    }

    /**
     * Copies all elements of arr to the current Uint8ClampedArray starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: int[], insertPos: int): void {
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: int[]): size of arr is greater than Uint8ClampedArray.length")
        }
        for (let i = 0; i < arr.length; i++) {
            this.setUnsafeClamp(insertPos + i, arr[i])
        }
    }

    /**
     * Copies all elements of arr to the current Uint8ClampedArray.
     *
     * @param arr array to copy data from
     */
    public set(arr: number[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies all elements of arr to the current Uint8ClampedArray.
     *
     * @param arr array to copy data from
     */
    public set(arr: int[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies elements from an ArrayLike object to the Uint8ClampedArray.
     *
     * @param array An ArrayLike object containing the elements to copy.
     *
     * @param offset Optional. The offset into the target array at which to begin writing values from the source array
     */
    public set(array: ArrayLike<number>, offset: number = 0): void {
        const insertPos = offset as int
        if (insertPos < 0 || insertPos + array.length > this.lengthInt) {
            throw new RangeError("offset is out of bounds")
        }
        for (let i = 0; i < array.length; i++) {
            this.setUnsafeClamp(insertPos as int + i as int, array[i] as int)
        }
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint8ClampedArray
     */
    public static of(...items: number[]): Uint8ClampedArray {
        let res = new Uint8ClampedArray(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, items[i] as int)
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint8ClampedArray
     */
    public static of(...items: int[]): Uint8ClampedArray {
        let res = new Uint8ClampedArray(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, items[i])
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint8ClampedArray
     */
    public static of(...items: short[]): Uint8ClampedArray {
        let res = new Uint8ClampedArray(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, items[i] as int)
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint8ClampedArray
     */
    public static of(): Uint8ClampedArray {
        return new Uint8ClampedArray(0 as int)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @returns new Uint8ClampedArray
     */
    public static from(arr: ArrayLike<number>): Uint8ClampedArray {
        return Uint8ClampedArray.from<number>(arr, (x: number, k: number): number => x)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new Uint8ClampedArray
     */
    public static from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number): Uint8ClampedArray {
        if (mapfn == undefined) {
            mapfn = (v: number, k: number): number => { return v }
        }
        // Calc length of items inside arrayLike, save length into i variable
        let i: long = 0
        let iter = arrayLike.$_iterator()
        while (true) {
            const v = iter.next()
            if (v.done) {
                break
            }
            i++
        }

        let res = new Uint8ClampedArray(i as int)
        i = 0
        iter = arrayLike.$_iterator()
        while (true) {
            const v = iter.next()
            if (v.done) {
                return res
            }
            res.setUnsafeClamp(i as int, (mapfn)!(v.value as number, i as number) as int)
            i++
        }
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new Uint8ClampedArray
     */
    public static from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number): Uint8ClampedArray {
        let res = new Uint8ClampedArray(arrayLike.length)
        // NOTE (ikorobkov): Please don't replace idx as int[1] with int-variable, because of value of single variable doesn't change (idx++) into lambda call by unknown reason
        const idx = new int[1]
        idx[0] = 0
        iteratorForEach<T>(arrayLike.$_iterator(), (x: T): void => {
            res.setUnsafeClamp(idx[0], mapfn(x as T, idx[0] as number) as int)
            idx[0] += 1
        })
        return res
    }

    /**
     * Determines whether Uint8ClampedArray includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint8ClampedArray, false otherwise
     */
    public includes(searchElement: number, fromIndex?: number): boolean {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0)) != -1
    }

    /**
     * Determines whether Uint8ClampedArray includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint8ClampedArray, false otherwise
     */
    public includes(searchElement: int, fromIndex: int): boolean {
        return this.indexOf(searchElement as int, fromIndex) != -1
    }

    /**
     * Determines whether Uint8ClampedArray includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint8ClampedArray, false otherwise
     */
    public includes(searchElement: int): boolean {
        return this.indexOf(searchElement as int, 0) != -1
    }

    /**
     * Returns the index of the first occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: number, fromIndex?: number): number {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the first occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: number, fromIndex: int): number {
        if (isNaN(searchElement)) {
            return -1
        }
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) as number == searchElement) {
                return i
            }
        }
        return -1
    }

    /**
     * Returns the index of the first occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int, fromIndex: int): number {
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) == searchElement) {
                return i
            }
        }
        return -1

    }

    /**
     * Returns the index of the first occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int): number {
        return this.indexOf(searchElement, 0)
    }

    /**
     * Adds all the elements of an array separated by the specified separator string
     *
     * @param separator A string used to separate one element of an array from the next in the
     * resulting String. If omitted, the array elements are separated with a comma
     *
     * @returns joined representation
     */
    public join(separator?: String): string {
        if (separator == undefined) {
            return this.join(",")
        }
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; i++) {
            res.append(this.getUnsafe(i) as number)
            res.append(separator)
        }
        if (this.lengthInt > 0) {
            res.append(this.getUnsafe(this.lengthInt - 1) as number)
        }
        return res.toString()
    }

    /**
     * Returns an list of keys in Uint8ClampedArray
     *
     * @returns iterator over keys
     */
    public keys(): IterableIterator<number> {
        return new Uint8ClampedArrayIteratorKeys(this)
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number, fromIndex: number|undefined): number {
        return this.lastIndexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number, fromIndex: int): number {
        if (isNaN(searchElement)) {
            return -1
        }
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) as number == searchElement) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int, fromIndex: int): number {
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) == searchElement) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8ClampedArray.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

   /**
    * Creates a new Uint8ClampedArray using initializer
    *
    * @param data initializer
    *
    * @returns a new Uint8ClampedArray from data
    */
    public of(...data: number[]): Uint8ClampedArray {
        throw new Error("Uint8ClampedArray.of: not implemented")
    }

    /**
     * Creates a new Uint8ClampedArray using reversed data from the current one
     *
     * @returns a new Uint8ClampedArray using reversed data from the current one
     */
    public reverse(): Uint8ClampedArray {
        for (let i: int = 0; i < this.lengthInt / 2 as int; i++) {
            const tmp = this.getUnsafe(this.lengthInt - 1 - i)
            this.setUnsafe(this.lengthInt - 1 - i, this.getUnsafe(i))
            this.setUnsafe(i, tmp)
        }
        return this
    }

    /**
     * Creates a slice of current Uint8ClampedArray using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8ClampedArray with elements of current Uint8ClampedArray[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin?: number, end?: number): Uint8ClampedArray {
        return this.slice(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a slice of current Uint8ClampedArray using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8ClampedArray with elements of current Uint8ClampedArray[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: number): Uint8ClampedArray {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint8ClampedArray using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8ClampedArray with elements of current Uint8ClampedArray[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: int): Uint8ClampedArray {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint8ClampedArray using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8ClampedArray with elements of current Uint8ClampedArray[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: number): Uint8ClampedArray {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint8ClampedArray using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8ClampedArray with elements of current Uint8ClampedArray[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: int): Uint8ClampedArray {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        if (this.buffer instanceof ArrayBuffer) {
            let buf = (this.buffer as ArrayBuffer).slice(relStart * Uint8ClampedArray.BYTES_PER_ELEMENT as int, relEnd * Uint8ClampedArray.BYTES_PER_ELEMENT as int) as ArrayBuffer
            return new Uint8ClampedArray(buf)
        } else if (this.buffer instanceof SharedArrayBuffer) {
            let buf = (this.buffer as SharedArrayBuffer).slice(relStart * Uint8ClampedArray.BYTES_PER_ELEMENT as int, relEnd * Uint8ClampedArray.BYTES_PER_ELEMENT as int) as SharedArrayBuffer
            return new Uint8ClampedArray(buf)
        } else {
            throw new Error("unexpected type of buffer")
        }
    }

    /**
     * Creates a slice of current Uint8ClampedArray using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new Uint8ClampedArray with elements of current Uint8ClampedArray[begin, this.lengthInt)
     */
    public slice(begin: number): Uint8ClampedArray {
        return this.slice(begin as int)
    }

    /**
     * Creates a slice of current Uint8ClampedArray using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new Uint8ClampedArray with elements of current Uint8ClampedArray[begin, this.lengthInt)
     */
    public slice(begin: int): Uint8ClampedArray {
        return this.slice(begin, this.lengthInt)
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     * If omitted, the elements are sorted in ascending order.
     *
     * @returns sorted Uint8ClampedArray
     */
    public sort(compareFn?: (a: number, b: number) => number): this {
        let arr: int[] = new int[this.lengthInt]
        for (let i = 0; i < this.lengthInt; ++i) {
            arr[i] = this.getUnsafe(i)
        }
        let cmp = (l: int, r: int): number => {
                return (l - r) as number
            }
        if (compareFn != undefined) {
            cmp = (l: int, r: int): number => {
                return compareFn!(l as number, r as number)
            }
        }
        sort(arr, cmp)
        for (let i = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr[i])
        }
        return this
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted Uint8ClampedArray
     */
    public sort(compareFn: (a: number) => number): this {
        let cmp = (a: number, b: number) => { return compareFn(a)}
        this.sort(cmp)
        return this
    }

    /**
     * Sorts in-place
     *
     * @param fn compareFn —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted Uint8ClampedArray
     */
    public sort(compareFn: () => number): this {
        let cmp = (a: number, b: number) => { return compareFn()}
        this.sort(cmp)
        return this
    }
    /**
     * Creates a Uint8ClampedArray with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8ClampedArray with the same underlying Buffer
     */
    public subarray(begin?: number, end?: number): Uint8ClampedArray {
        return this.subarray(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a Uint8ClampedArray with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8ClampedArray with the same underlying Buffer
     */
    public subarray(begin: number, end: number): Uint8ClampedArray {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint8ClampedArray with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8ClampedArray with the same underlying Buffer
     */
    public subarray(begin: number, end: int): Uint8ClampedArray {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint8ClampedArray with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8ClampedArray with the same underlying Buffer
     */
    public subarray(begin: int, end: number): Uint8ClampedArray {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint8ClampedArray with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8ClampedArray with the same underlying Buffer
     */
    public subarray(begin: int, end: int): Uint8ClampedArray {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        return new Uint8ClampedArray(this.buffer, relStart * Uint8ClampedArray.BYTES_PER_ELEMENT as int, count)
    }

    /**
     * Creates a Uint8ClampedArray with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new Uint8ClampedArray with the same Buffer
     */
    public subarray(begin: number): Uint8ClampedArray {
        return this.subarray(begin as int, this.lengthInt)
    }

    /**
     * Creates a Uint8ClampedArray with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new Uint8ClampedArray with the same Buffer
     */
    public subarray(begin: int): Uint8ClampedArray {
        return this.subarray(begin, this.lengthInt)
    }

    /**
     * Converts Uint8ClampedArray to a string with respect to locale
     *
     * @param locales
     *
     * @param options
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object, options: Object): string {
        throw new Error("Uint8ClampedArray.toLocaleString: not implemented")
    }

    /**
     * Converts Uint8ClampedArray to a string with respect to locale
     *
     * @param locales
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object): string {
        return this.toLocaleString(new Object(), new Object())
    }

    /**
     * Converts Uint8ClampedArray to a string with respect to locale
     *
     * @returns string representation
     */
    public toLocaleString(): string {
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; ++i) {
            res.append((this.getUnsafe(i) as Number).toLocaleString())
            res.append(",")
        }
        if (this.lengthInt > 0) {
            res.append((this.getUnsafe(this.lengthInt - 1) as Number).toLocaleString())
        }
        return res.toString()
    }

    /**
     * Creates a reversed copy
     *
     * @returns a reversed copy
     */
    public toReversed(): Uint8ClampedArray {
        return new Uint8ClampedArray(this).reverse()
    }

    /**
     * Creates a sorted copy
     *
     * @returns a sorted copy
     */
    public toSorted(): Uint8ClampedArray {
        return new Uint8ClampedArray(this).sort()
    }

    /**
     * Returns a string representation of the Uint8ClampedArray
     *
     * @returns a string representation of the Uint8ClampedArray
     */
    public override toString(): string {
        return this.join(",")
    }

    /**
     * Returns array values iterator
     *
     * @returns an iterator
     */
    public values(): IterableIterator<Number> {
         return new Uint8ClampedArrayIterator(this)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an Uint8ClampedArray with replaced value on index
     */
    public with(index: number, value: number): Uint8ClampedArray {
        return this.with(index as int, value as int)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an Uint8ClampedArray with replaced value on index
     */
    /* public */ internal with(index: int, value: int): Uint8ClampedArray {
        let res = new Uint8ClampedArray(this)
        res.setUnsafeClamp(index, value)
        return res
    }

    /// === with element lambda functions ===

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts one argument.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number) => boolean): boolean {
        return this.every((element: number, index: number, array: Uint8ClampedArray): boolean => predicate(element))
    }

    /**
     * creates a new Uint8ClampedArray from current Uint8ClampedArray based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint8ClampedArray with elements from current Uint8ClampedArray that satisfy condition fn
     */
    public filter(fn: (val: number) => boolean): Uint8ClampedArray {
        let newF: (val: number, index: number, array: Uint8ClampedArray) => boolean =
            (val: number, index: number, array: Uint8ClampedArray): boolean => { return fn(val) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: () => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint8ClampedArray): boolean => predicate())
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number) => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint8ClampedArray): boolean => predicate(value))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number) => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint8ClampedArray): boolean => predicate(value)) as number
    }

    /**
     * Finds the last element in the Uint8ClampedArray that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint8ClampedArray) => boolean =
            (val: number, index: number, array: Uint8ClampedArray): boolean => { return fn(val) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the Uint8ClampedArray that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint8ClampedArray) => boolean =
            (val: number, index: number, array: Uint8ClampedArray): boolean => { return fn(val) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in Uint8ClampedArray
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (val: number) => void): void {
        this.forEach((value: number, index: number, array: Uint8ClampedArray): void => callbackfn(value))
    }

    /**
     * Creates a new Uint8ClampedArray using fn(arr[i]) over all elements of current Uint8ClampedArray
     *
     * @param fn a function to apply for each element of current Uint8ClampedArray
     *
     * @returns a new Uint8ClampedArray where for each element from current Uint8ClampedArray fn was applied
     */
    public map(fn: (val: number) => number): Uint8ClampedArray {
        let newF: (val: number, index: number) => number =
            (val: number, index: number): number => { return fn(val) }
        return this.map(newF)
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts one argument.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number) => boolean): boolean {
        return this.some((element: number, index: number, array: Uint8ClampedArray): boolean => predicate(element))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number, index: number, array: Uint8ClampedArray) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(this.getUnsafe(i) as number, i as number, this)) {
                return true
            }
        }
        return false
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number, index: number) => boolean): boolean {
        return this.some((element: number, index: number, array: Uint8ClampedArray): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: () => boolean): boolean {
        return this.some((element: number, index: number, array: Uint8ClampedArray): boolean => predicate())
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = 0; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue = this.$_get(0) as number
        for (let i = 1; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal, currVal, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal, currVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: () => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn())
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U, currentValue: number, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U, currentValue: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue: number = this.$_get(this.lengthInt - 1) as number
        for (let i = this.lengthInt - 2; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevValue, currValue, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevValue, currValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn(prevValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: () => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint8ClampedArray) =>
                        callbackfn())
    }

    /**
     * Creates a new Uint8ClampedArray using fn(arr[i]) over all elements of current Uint8ClampedArray.
     *
     * @param fn a function to apply for each element of current Uint8ClampedArray
     *
     * @returns a new Uint8ClampedArray where for each element from current Uint8ClampedArray fn was applied
     */
    public map(fn: (val: number, index: number) => number): Uint8ClampedArray {
        let resBuf = new ArrayBuffer(this.lengthInt * Uint8ClampedArray.BYTES_PER_ELEMENT as int)
        let res = new Uint8ClampedArray(resBuf)
        for (let i = 0; i < this.lengthInt; i++) {
            const fnRes = fn(this.getUnsafe(i) as number, i as number)
            res.setUnsafeClamp(i, fnRes as int)
        }
        return res
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number, index: number, array: Uint8ClampedArray) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (!predicate(this.getUnsafe(i) as number, i as number, this)) {
                return false
            }
        }
        return true
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number, index: number) => boolean): boolean {
        return this.every((element: number, index: number, array: Uint8ClampedArray): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: () => boolean): boolean {
        return this.every((element: number, index: number, array: Uint8ClampedArray): boolean => predicate())
    }

    /**
     * Creates a new Uint8ClampedArray from current Uint8ClampedArray based on a condition fn.
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint8ClampedArray with elements from current Uint8ClampedArray that satisfy condition fn
     */
    public filter(fn: (val: number, index: number, array: Uint8ClampedArray) => boolean): Uint8ClampedArray {
        let markers = new boolean[this.lengthInt]
        let resLen = 0
        for (let i = 0; i < this.lengthInt; i++) {
            markers[i] = fn(this.getUnsafe(i) as number, i as number, this)
            if (markers[i]) {
                ++resLen
            }
        }
        let res = new Uint8ClampedArray(resLen)
        for (let i = 0, j = 0; i < this.lengthInt; i++) {
            if (markers[i]) {
                res.setUnsafe(j, this.getUnsafe(i))
                ++j
            }
        }
        return res
    }

    /**
     * creates a new Uint8ClampedArray from current Uint8ClampedArray based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint8ClampedArray with elements from current Uint8ClampedArray that satisfy condition fn
     */
    public filter(fn: (val: number, index: number) => boolean): Uint8ClampedArray {
        let newF: (val: number, index: number, array: Uint8ClampedArray) => boolean =
            (val: number, index: number, array: Uint8ClampedArray): boolean => { return fn(val, index) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number, index: number, array: Uint8ClampedArray) => boolean): number | undefined {
        for (let i = 0; i < this.lengthInt; i++) {
            let val = this.getUnsafe(i) as number
            if (predicate(val, i as number, this)) {
                return val
            }
        }
        return undefined
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number, index: number) => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint8ClampedArray): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean): number {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(this.getUnsafe(i) as number, i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number, index: number) => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint8ClampedArray): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: () => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint8ClampedArray): boolean => predicate())
    }

    /**
     * Finds the last element in the Uint8ClampedArray that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number, index: number, array: Uint8ClampedArray) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            let val = this.getUnsafe(i) as number
            if (fn(val, i as number, this)) {
                return val
            }
        }
        throw new Error("Uint8ClampedArray.findLast: not implemented if an element was not found")
    }

    /**
     * Finds the last element in the Uint8ClampedArray that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number, index: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint8ClampedArray) => boolean =
            (val: number, index: number, array: Uint8ClampedArray): boolean => { return fn(val, index) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the Uint8ClampedArray that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number, index: number, array: Uint8ClampedArray) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            if (fn(this.getUnsafe(i) as number, i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Finds an index of the last element in the Uint8ClampedArray that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number, index: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint8ClampedArray) => boolean =
            (val: number, index: number, array: Uint8ClampedArray): boolean => { return fn(val, index) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in Uint8ClampedArray
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => void): void {
        for (let i = 0; i < this.lengthInt; i++) {
            callbackfn(this.getUnsafe(i) as number, i as number, this)
        }
    }

    /**
     * Performs the specified action for each element in Uint8ClampedArray
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: number, index: number) => void): void {
        this.forEach((value: number, index: number, array: Uint8ClampedArray): void => callbackfn(value, index))
    }

    /**
     * Performs the specified action for each element in Uint8ClampedArray
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: () => void): void {
        this.forEach((value: number, index: number, array: Uint8ClampedArray): void => callbackfn())
    }

    /**
     * Returns the object itself
     *
     * @returns Uint8ClampedArray
     */
    public valueOf(): Uint8ClampedArray {
        return this
    }

    /** Byte offset within the underlying Buffer */
    public get byteOffset(): number {
        return this.byteOffsetInt
    }

    /** Number of bytes used */
    public get byteLength(): number {
        return this.byteLengthInt
    }

    /** Number of int stored in Uint8ClampedArray */
    public get length(): number {
        return this.lengthInt
    }

    /** String \"Uint8ClampedArray\" */
    public readonly name = "Uint8ClampedArray"

    private static clamp(val: int): int {
        if (val > 255) {
            val = 255
        } else if (val < 0) {
            val = 0
        }
        return val
    }

    internal setUnsafeClamp(insertPos: int, val: int): void {
        val = Uint8ClampedArray.clamp(val)
        this.setUnsafe(insertPos, val)
    }

    internal getUnsafe(index: int): int {
        index = index * Uint8ClampedArray.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: int = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint8ClampedArray.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint8ClampedArray.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint8ClampedArray.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + 0 - i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint8ClampedArray.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + 0 - i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
        return res
    }

    internal setUnsafe(index: int, val: int): void {
        index = index * Uint8ClampedArray.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: int = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint8ClampedArray.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint8ClampedArray.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint8ClampedArray.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + 0 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint8ClampedArray.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + 0 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
    }
}


class Uint8ArrayIteratorKeys implements IterableIterator<number> {
    private length: int = 0
    private idx: int = 0

    constructor(parent: Uint8Array) {
        this.length = parent.length as int
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<number> {
        if (this.idx < 0 || this.idx >= this.length) {
            return new IteratorResult<number>()
        }
        return new IteratorResult<number>(false, this.idx++ as number)
    }
}

class Uint8ArrayIterator implements IterableIterator<Number> {
    private parent: Uint8Array
    private idx: int = 0

    constructor(parent: Uint8Array) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<Number> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<Number>()
        }
        return new IteratorResult<Number>(false, new Number(this.parent.getUnsafe(this.idx++)))
    }
}

class Uint8ArrayIteratorEntries implements IterableIterator<[Number, Number]> {
    private parent: Uint8Array
    private idx: int = 0

    constructor(parent: Uint8Array) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<[Number, Number]> {
        return this
    }

    override next(): IteratorResult<[Number, Number]> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<[Number, Number]>()
        }
        return new IteratorResult<[Number, Number]>(
            false,
            [new Number(this.idx), new Number(this.parent.getUnsafe(this.idx++))]
        )
    }
}

/**
 * JS Uint8Array API-compatible class
 */
export class Uint8Array implements Iterable<Number>, ArrayLike<Number> {
    public static readonly BYTES_PER_ELEMENT: number = 1

    /** Underlying Buffer */
    public readonly buffer: ArrayBufferLike

    internal readonly byteOffsetInt: int
    internal readonly byteLengthInt: int
    internal readonly lengthInt: int

    /**
     * Creates an empty Uint8Array.
     */
    public constructor() {
        this(0 as int)
    }

    /**
     * Creates an Uint8Array with respect to data accessed via Iterable<Number> interface
     */
    public constructor(elements: Iterable<Number>) {
        // NOTE (ikorobkov): dealing with this overload is tricky
        // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
        let arr = Array.from<Number>(elements)
        this.byteLengthInt = arr.length as int * Uint8Array.BYTES_PER_ELEMENT as int
        this.lengthInt = arr.length as int
        this.buffer = new ArrayBuffer(this.byteLengthInt)
        this.byteOffsetInt = 0
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr.$_get(i).intValue())
        }
    }

    /**
     * Creates an Uint8Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint8Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined, length: Number | undefined) {
        let intByteOffset: int = 0
        if (byteOffset != undefined) {
            intByteOffset = byteOffset.intValue()
            if (intByteOffset < 0) {
                throw new RangeError("Range Error: byteOffset " + intByteOffset + " is outside the bounds of the buffer")
            }
        }
        let intByteLength: int
        if (buf instanceof ArrayBuffer) {
            intByteLength = (buf as ArrayBuffer).getByteLength()
        } else if (buf instanceof SharedArrayBuffer) {
            intByteLength = (buf as SharedArrayBuffer).getByteLength()
        } else {
            throw new Error("unexpected type of ArrayBufferLike")
        }
        intByteLength = intByteLength - intByteOffset
        if (intByteLength < 0) {
            throw new RangeError("Range Error: byteLength " + intByteLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
        }

        let intLength: int
        if (length != undefined) {
            intLength = length.intValue()
            if (intLength > intByteLength / Uint8Array.BYTES_PER_ELEMENT as int) {
                throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
            }
        } else {
            intLength = intByteLength / Uint8Array.BYTES_PER_ELEMENT as int
        }
        if (intLength < 0) {
            throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer")
        }
        if (intLength < intByteLength / Uint8Array.BYTES_PER_ELEMENT as int) {
            intByteLength = intLength * Uint8Array.BYTES_PER_ELEMENT as int
        }
        this.byteLengthInt = intByteLength
        this.byteOffsetInt = intByteOffset
        this.lengthInt = intLength
        this.buffer = buf
    }

    /**
     * Creates an Uint8Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined) {
        this(buf, byteOffset, undefined)
    }

    /**
     * Creates an Uint8Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint8Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number, length: number) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an Uint8Array with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an Uint8Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint8Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int, length: int) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an Uint8Array with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an Uint8Array with respect to buf.
     *
     * @param buf data initializer
     */
    public constructor(buf: ArrayLike<Number> | ArrayBufferLike) {
        if (buf instanceof ArrayBuffer) {
            this.byteLengthInt = (buf as ArrayBuffer).getByteLength()
            if (this.byteLengthInt % Uint8Array.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of int as Uint8Array.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / Uint8Array.BYTES_PER_ELEMENT as int
            this.buffer = buf as ArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof SharedArrayBuffer) {
            this.byteLengthInt = (buf as SharedArrayBuffer).getByteLength()
            if (this.byteLengthInt % Uint8Array.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of int as Uint8Array.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / Uint8Array.BYTES_PER_ELEMENT as int
            this.buffer = buf as SharedArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof ArrayLike) {
            // NOTE (ikorobkov): dealing with this overload is tricky
            // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
            let arr = Array.from<Number>((buf as ArrayLike<Number>))
            this.byteLengthInt = arr.length as int * Uint8Array.BYTES_PER_ELEMENT as int
            this.lengthInt = arr.length as int
            this.buffer = new ArrayBuffer(this.byteLengthInt)
            this.byteOffsetInt = 0
            for (let i: int = 0; i < this.lengthInt; ++i) {
                this.setUnsafe(i, arr.$_get(i).intValue())
            }
        } else {
            throw new Error("unexpected type of buf")
        }
    }

    /**
     * Creates an Uint8Array with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: int) {
        if (length < 0) {
            throw new RangeError("Range Error: length " + length + " is outside the bounds of the buffer")
        }
        this.lengthInt = length
        this.byteLengthInt = length * Uint8Array.BYTES_PER_ELEMENT as int
        this.byteOffsetInt = 0
        this.buffer = new ArrayBuffer(this.byteLengthInt)
    }

    /**
     * Creates an Uint8Array with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: number) {
        this(length as int)
    }

    /**
     * Creates a copy of Uint8Array.
     *
     * @param other data initializer
     */
    public constructor(other: Uint8Array) {
        if (other.buffer instanceof ArrayBuffer) {
            this.buffer = (other.buffer as ArrayBuffer).slice(0 as int, other.byteLength as int) as ArrayBuffer
        } else if (other.buffer instanceof SharedArrayBuffer) {
            this.buffer = (other.buffer as SharedArrayBuffer).slice(0 as int, other.byteLength as int) as SharedArrayBuffer
        } else {
            throw new Error("unexpected type of buffer")
        }
        this.byteLengthInt = other.byteLength as int
        this.lengthInt = other.length as int
        this.byteOffsetInt = 0
    }

    /**
     * Creates an Uint8Array from number[]
     */
    public constructor(numbers: number[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, this.zeroIfInfinity(numbers[i]) as int)
        }
    }

    /**
     * Creates an Uint8Array from int[]
     */
    public constructor(numbers: int[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, this.zeroIfInfinity(numbers[i]) as int)
        }
    }

    internal zeroIfInfinity(val: number): number {
        if ((val == Infinity) || (val == -Infinity)) {
            return 0 as number
        }
        return val as number
    }

    internal zeroIfInfinity(val: int): int {
        if ((val == Infinity) || (val == -Infinity)) {
            return 0 as int
        }
        return val
    }

    /**
     * Iteratorable interface implementation
     *
     * @returns iterator over all elements
     */
    public override $_iterator(): IterableIterator<Number> {
         return this.values()
    }

    /**
     * Returns an instance of primitive type at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: number): Number | undefined {
        return this.at(index as int)
    }

    /**
     * Returns an instance of primitive type at passed index if index is correct.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: int): Number | undefined {
        let k: int
        if (index >= 0) {
            k = index
        } else {
            k = this.lengthInt + index
        }
        if (k < 0 || k >= this.lengthInt) {
            return undefined
        }
        return new Number(this.getUnsafe(k))
    }

    /**
     * Returns an instance of number at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public override $_get(index: number): Number {
        return this.$_get(index as int) as Number
    }

    /**
     * Returns an instance of number at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public $_get(i: int): number {
        if (i < 0 || i >= this.lengthInt) {
            throw new RangeError("invalid offset")
        }
        return this.getUnsafe(i) as number
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: number): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: number): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val)
        this.setUnsafeClamp(index, v as int)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: int): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: int): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val)
        this.setUnsafeClamp(index, v)
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: number, end?: number): Uint8Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: number, end?: number): Uint8Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: int, end?: number): Uint8Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end?: number): Uint8Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param insert insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end: int): Uint8Array {
        let toPos = normalizeIndex(target, this.lengthInt)
        let fromPos = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        let count: int = finalPos - fromPos
        if (count > (this.lengthInt - toPos)) {
            count = this.lengthInt - toPos
        }
        let direction: int = 1
        if ((fromPos < toPos) && (toPos < fromPos + count)) {
            fromPos = fromPos + count - 1
            toPos   = toPos   + count - 1
            direction = -1
        }
        while (count > 0) {
            const value = this.getUnsafe(fromPos)
            this.setUnsafe(toPos, value)
            fromPos = fromPos + direction
            toPos = toPos + direction
            --count
        }
        return this
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of Uint8Array.
     *
     * @param target insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: number): Uint8Array {
        return this.copyWithin(target as int)
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of Uint8Array.
     *
     * @param insert insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: int): Uint8Array {
        return this.copyWithin(target, 0, this.lengthInt)
    }

    /**
     * Returns an array of key, value pairs for every entry in the Uint8Array
     *
     * @returns key, value pairs for every entry in the array
     */
    public entries(): IterableIterator<[Number, Number]> {
        return new Uint8ArrayIteratorEntries(this)
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: number, start?: number, end?: number): Uint8Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: number, start: int, end?: number): Uint8Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: number, start: int, end: number): Uint8Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: number, start: number, end: int): Uint8Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: number, start: int, end: int): Uint8Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: int, start?: number, end?: number): Uint8Array {
        this.fill(value, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: int, start: int, end?: number): Uint8Array {
        this.fill(value, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: int, start: int, end: number): Uint8Array {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: int, start: number, end: int): Uint8Array {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint8Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint8Array
     */
    public fill(value: int, start: int, end: int): Uint8Array {
        const k = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        for (let i: int = k; i < finalPos; ++i) {
            this.setUnsafe(i, value)
        }
        return this
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: number): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: number): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: int): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: int): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Copies all elements of arr to the current Uint8Array starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: number[], insertPos1: number): void {
        const insertPos = insertPos1 as int
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: int[]): size of arr is greater than Uint8Array.length")
        }
        for (let i = 0; i < arr.length; i++) {
            let v = this.zeroIfInfinity(arr[i])
            this.setUnsafeClamp(insertPos as int + i as int, v as int)
        }
    }

    /**
     * Copies all elements of arr to the current Uint8Array starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: int[], insertPos: int): void {
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: int[]): size of arr is greater than Uint8Array.length")
        }
        for (let i = 0; i < arr.length; i++) {
            let v = this.zeroIfInfinity(arr[i])
            this.setUnsafeClamp(insertPos + i, v)
        }
    }

    /**
     * Copies all elements of arr to the current Uint8Array.
     *
     * @param arr array to copy data from
     */
    public set(arr: number[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies all elements of arr to the current Uint8Array.
     *
     * @param arr array to copy data from
     */
    public set(arr: int[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies elements from an ArrayLike object to the Uint8Array.
     *
     * @param array An ArrayLike object containing the elements to copy.
     *
     * @param offset Optional. The offset into the target array at which to begin writing values from the source array
     */
    public set(array: ArrayLike<number>, offset: number = 0): void {
        const insertPos = offset as int
        if (insertPos < 0 || insertPos + array.length > this.lengthInt) {
            throw new RangeError("offset is out of bounds")
        }
        for (let i = 0; i < array.length; i++) {
            let v = this.zeroIfInfinity(array[i])
            this.setUnsafeClamp(insertPos as int + i as int, v as int)
        }
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint8Array
     */
    public static of(...items: number[]): Uint8Array {
        let res = new Uint8Array(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, res.zeroIfInfinity(items[i]) as int)
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint8Array
     */
    public static of(...items: int[]): Uint8Array {
        let res = new Uint8Array(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, items[i])
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint8Array
     */
    public static of(...items: short[]): Uint8Array {
        let res = new Uint8Array(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, items[i] as int)
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint8Array
     */
    public static of(): Uint8Array {
        return new Uint8Array(0 as int)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @returns new Uint8Array
     */
    public static from(arr: ArrayLike<number>): Uint8Array {
        return Uint8Array.from<number>(arr, (x: number, k: number): number => x)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new Uint8Array
     */
    public static from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number): Uint8Array {
        if (mapfn == undefined) {
            mapfn = (v: number, k: number): number => { return v }
        }
        // Calc length of items inside arrayLike, save length into i variable
        let i: long = 0
        let iter = arrayLike.$_iterator()
        while (true) {
            const v = iter.next()
            if (v.done) {
                break
            }
            i++
        }

        let res = new Uint8Array(i as int)
        i = 0
        iter = arrayLike.$_iterator()
        while (true) {
            const v = iter.next()
            if (v.done) {
                return res
            }
            res.setUnsafeClamp(i as int, res.zeroIfInfinity((mapfn)!(v.value as number, i as number)) as int)
            i++
        }
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new Uint8Array
     */
    public static from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number): Uint8Array {
        let res = new Uint8Array(arrayLike.length)
        // NOTE (ikorobkov): Please don't replace idx as int[1] with int-variable, because of value of single variable doesn't change (idx++) into lambda call by unknown reason
        const idx = new int[1]
        idx[0] = 0
        iteratorForEach<T>(arrayLike.$_iterator(), (x: T): void => {
            res.setUnsafeClamp(idx[0], res.zeroIfInfinity(mapfn(x as T, idx[0] as number)) as int)
            idx[0] += 1
        })
        return res
    }

    /**
     * Determines whether Uint8Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint8Array, false otherwise
     */
    public includes(searchElement: number, fromIndex?: number): boolean {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0)) != -1
    }

    /**
     * Determines whether Uint8Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint8Array, false otherwise
     */
    public includes(searchElement: int, fromIndex: int): boolean {
        return this.indexOf(searchElement as int, fromIndex) != -1
    }

    /**
     * Determines whether Uint8Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint8Array, false otherwise
     */
    public includes(searchElement: int): boolean {
        return this.indexOf(searchElement as int, 0) != -1
    }

    /**
     * Returns the index of the first occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: number, fromIndex?: number): number {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the first occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: number, fromIndex: int): number {
        if (isNaN(searchElement)) {
            return -1
        }
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) as number == searchElement) {
                return i
            }
        }
        return -1
    }

    /**
     * Returns the index of the first occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int, fromIndex: int): number {
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) == searchElement) {
                return i
            }
        }
        return -1

    }

    /**
     * Returns the index of the first occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int): number {
        return this.indexOf(searchElement, 0)
    }

    /**
     * Adds all the elements of an array separated by the specified separator string
     *
     * @param separator A string used to separate one element of an array from the next in the
     * resulting String. If omitted, the array elements are separated with a comma
     *
     * @returns joined representation
     */
    public join(separator?: String): string {
        if (separator == undefined) {
            return this.join(",")
        }
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; i++) {
            res.append(this.getUnsafe(i) as number)
            res.append(separator)
        }
        if (this.lengthInt > 0) {
            res.append(this.getUnsafe(this.lengthInt - 1) as number)
        }
        return res.toString()
    }

    /**
     * Returns an list of keys in Uint8Array
     *
     * @returns iterator over keys
     */
    public keys(): IterableIterator<number> {
        return new Uint8ArrayIteratorKeys(this)
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number, fromIndex: number|undefined): number {
        return this.lastIndexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number, fromIndex: int): number {
        if (isNaN(searchElement)) {
            return -1
        }
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) as number == searchElement) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int, fromIndex: int): number {
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) == searchElement) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in Uint8Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

   /**
    * Creates a new Uint8Array using initializer
    *
    * @param data initializer
    *
    * @returns a new Uint8Array from data
    */
    public of(...data: number[]): Uint8Array {
        throw new Error("Uint8Array.of: not implemented")
    }

    /**
     * Creates a new Uint8Array using reversed data from the current one
     *
     * @returns a new Uint8Array using reversed data from the current one
     */
    public reverse(): Uint8Array {
        for (let i: int = 0; i < this.lengthInt / 2 as int; i++) {
            const tmp = this.getUnsafe(this.lengthInt - 1 - i)
            this.setUnsafe(this.lengthInt - 1 - i, this.getUnsafe(i))
            this.setUnsafe(i, tmp)
        }
        return this
    }

    /**
     * Creates a slice of current Uint8Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8Array with elements of current Uint8Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin?: number, end?: number): Uint8Array {
        return this.slice(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a slice of current Uint8Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8Array with elements of current Uint8Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: number): Uint8Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint8Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8Array with elements of current Uint8Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: int): Uint8Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint8Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8Array with elements of current Uint8Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: number): Uint8Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint8Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint8Array with elements of current Uint8Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: int): Uint8Array {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        if (this.buffer instanceof ArrayBuffer) {
            let buf = (this.buffer as ArrayBuffer).slice(relStart * Uint8Array.BYTES_PER_ELEMENT as int, relEnd * Uint8Array.BYTES_PER_ELEMENT as int) as ArrayBuffer
            return new Uint8Array(buf)
        } else if (this.buffer instanceof SharedArrayBuffer) {
            let buf = (this.buffer as SharedArrayBuffer).slice(relStart * Uint8Array.BYTES_PER_ELEMENT as int, relEnd * Uint8Array.BYTES_PER_ELEMENT as int) as SharedArrayBuffer
            return new Uint8Array(buf)
        } else {
            throw new Error("unexpected type of buffer")
        }
    }

    /**
     * Creates a slice of current Uint8Array using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new Uint8Array with elements of current Uint8Array[begin, this.lengthInt)
     */
    public slice(begin: number): Uint8Array {
        return this.slice(begin as int)
    }

    /**
     * Creates a slice of current Uint8Array using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new Uint8Array with elements of current Uint8Array[begin, this.lengthInt)
     */
    public slice(begin: int): Uint8Array {
        return this.slice(begin, this.lengthInt)
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     * If omitted, the elements are sorted in ascending order.
     *
     * @returns sorted Uint8Array
     */
    public sort(compareFn?: (a: number, b: number) => number): this {
        let arr: int[] = new int[this.lengthInt]
        for (let i = 0; i < this.lengthInt; ++i) {
            arr[i] = this.getUnsafe(i)
        }
        let cmp = (l: int, r: int): number => {
                return (l - r) as number
            }
        if (compareFn != undefined) {
            cmp = (l: int, r: int): number => {
                return compareFn!(l as number, r as number)
            }
        }
        sort(arr, cmp)
        for (let i = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr[i])
        }
        return this
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted Uint8Array
     */
    public sort(compareFn: (a: number) => number): this {
        let cmp = (a: number, b: number) => { return compareFn(a)}
        this.sort(cmp)
        return this
    }

    /**
     * Sorts in-place
     *
     * @param fn compareFn —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted Uint8Array
     */
    public sort(compareFn: () => number): this {
        let cmp = (a: number, b: number) => { return compareFn()}
        this.sort(cmp)
        return this
    }
    /**
     * Creates a Uint8Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8Array with the same underlying Buffer
     */
    public subarray(begin?: number, end?: number): Uint8Array {
        return this.subarray(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a Uint8Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8Array with the same underlying Buffer
     */
    public subarray(begin: number, end: number): Uint8Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint8Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8Array with the same underlying Buffer
     */
    public subarray(begin: number, end: int): Uint8Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint8Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8Array with the same underlying Buffer
     */
    public subarray(begin: int, end: number): Uint8Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint8Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint8Array with the same underlying Buffer
     */
    public subarray(begin: int, end: int): Uint8Array {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        return new Uint8Array(this.buffer, relStart * Uint8Array.BYTES_PER_ELEMENT as int, count)
    }

    /**
     * Creates a Uint8Array with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new Uint8Array with the same Buffer
     */
    public subarray(begin: number): Uint8Array {
        return this.subarray(begin as int, this.lengthInt)
    }

    /**
     * Creates a Uint8Array with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new Uint8Array with the same Buffer
     */
    public subarray(begin: int): Uint8Array {
        return this.subarray(begin, this.lengthInt)
    }

    /**
     * Converts Uint8Array to a string with respect to locale
     *
     * @param locales
     *
     * @param options
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object, options: Object): string {
        throw new Error("Uint8Array.toLocaleString: not implemented")
    }

    /**
     * Converts Uint8Array to a string with respect to locale
     *
     * @param locales
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object): string {
        return this.toLocaleString(new Object(), new Object())
    }

    /**
     * Converts Uint8Array to a string with respect to locale
     *
     * @returns string representation
     */
    public toLocaleString(): string {
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; ++i) {
            res.append((this.getUnsafe(i) as Number).toLocaleString())
            res.append(",")
        }
        if (this.lengthInt > 0) {
            res.append((this.getUnsafe(this.lengthInt - 1) as Number).toLocaleString())
        }
        return res.toString()
    }

    /**
     * Creates a reversed copy
     *
     * @returns a reversed copy
     */
    public toReversed(): Uint8Array {
        return new Uint8Array(this).reverse()
    }

    /**
     * Creates a sorted copy
     *
     * @returns a sorted copy
     */
    public toSorted(): Uint8Array {
        return new Uint8Array(this).sort()
    }

    /**
     * Returns a string representation of the Uint8Array
     *
     * @returns a string representation of the Uint8Array
     */
    public override toString(): string {
        return this.join(",")
    }

    /**
     * Returns array values iterator
     *
     * @returns an iterator
     */
    public values(): IterableIterator<Number> {
         return new Uint8ArrayIterator(this)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an Uint8Array with replaced value on index
     */
    public with(index: number, value: number): Uint8Array {
        return this.with(index as int, value as int)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an Uint8Array with replaced value on index
     */
    /* public */ internal with(index: int, value: int): Uint8Array {
        let res = new Uint8Array(this)
        res.setUnsafeClamp(index, value)
        return res
    }

    /// === with element lambda functions ===

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts one argument.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number) => boolean): boolean {
        return this.every((element: number, index: number, array: Uint8Array): boolean => predicate(element))
    }

    /**
     * creates a new Uint8Array from current Uint8Array based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint8Array with elements from current Uint8Array that satisfy condition fn
     */
    public filter(fn: (val: number) => boolean): Uint8Array {
        let newF: (val: number, index: number, array: Uint8Array) => boolean =
            (val: number, index: number, array: Uint8Array): boolean => { return fn(val) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: () => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint8Array): boolean => predicate())
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number) => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint8Array): boolean => predicate(value))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number) => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint8Array): boolean => predicate(value)) as number
    }

    /**
     * Finds the last element in the Uint8Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint8Array) => boolean =
            (val: number, index: number, array: Uint8Array): boolean => { return fn(val) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the Uint8Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint8Array) => boolean =
            (val: number, index: number, array: Uint8Array): boolean => { return fn(val) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in Uint8Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (val: number) => void): void {
        this.forEach((value: number, index: number, array: Uint8Array): void => callbackfn(value))
    }

    /**
     * Creates a new Uint8Array using fn(arr[i]) over all elements of current Uint8Array
     *
     * @param fn a function to apply for each element of current Uint8Array
     *
     * @returns a new Uint8Array where for each element from current Uint8Array fn was applied
     */
    public map(fn: (val: number) => number): Uint8Array {
        let newF: (val: number, index: number) => number =
            (val: number, index: number): number => { return fn(val) }
        return this.map(newF)
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts one argument.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number) => boolean): boolean {
        return this.some((element: number, index: number, array: Uint8Array): boolean => predicate(element))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number, index: number, array: Uint8Array) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(this.getUnsafe(i) as number, i as number, this)) {
                return true
            }
        }
        return false
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number, index: number) => boolean): boolean {
        return this.some((element: number, index: number, array: Uint8Array): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: () => boolean): boolean {
        return this.some((element: number, index: number, array: Uint8Array): boolean => predicate())
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = 0; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue = this.$_get(0) as number
        for (let i = 1; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal, currVal, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal, currVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: () => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn())
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U, currentValue: number, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U, currentValue: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue: number = this.$_get(this.lengthInt - 1) as number
        for (let i = this.lengthInt - 2; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevValue, currValue, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevValue, currValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint8Array) =>
                        callbackfn(prevValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: () => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint8Array) =>
                        callbackfn())
    }

    /**
     * Creates a new Uint8Array using fn(arr[i]) over all elements of current Uint8Array.
     *
     * @param fn a function to apply for each element of current Uint8Array
     *
     * @returns a new Uint8Array where for each element from current Uint8Array fn was applied
     */
    public map(fn: (val: number, index: number) => number): Uint8Array {
        let resBuf = new ArrayBuffer(this.lengthInt * Uint8Array.BYTES_PER_ELEMENT as int)
        let res = new Uint8Array(resBuf)
        for (let i = 0; i < this.lengthInt; i++) {
            const fnRes = fn(this.getUnsafe(i) as number, i as number)
            res.setUnsafeClamp(i, fnRes as int)
        }
        return res
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number, index: number, array: Uint8Array) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (!predicate(this.getUnsafe(i) as number, i as number, this)) {
                return false
            }
        }
        return true
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number, index: number) => boolean): boolean {
        return this.every((element: number, index: number, array: Uint8Array): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: () => boolean): boolean {
        return this.every((element: number, index: number, array: Uint8Array): boolean => predicate())
    }

    /**
     * Creates a new Uint8Array from current Uint8Array based on a condition fn.
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint8Array with elements from current Uint8Array that satisfy condition fn
     */
    public filter(fn: (val: number, index: number, array: Uint8Array) => boolean): Uint8Array {
        let markers = new boolean[this.lengthInt]
        let resLen = 0
        for (let i = 0; i < this.lengthInt; i++) {
            markers[i] = fn(this.getUnsafe(i) as number, i as number, this)
            if (markers[i]) {
                ++resLen
            }
        }
        let res = new Uint8Array(resLen)
        for (let i = 0, j = 0; i < this.lengthInt; i++) {
            if (markers[i]) {
                res.setUnsafe(j, this.getUnsafe(i))
                ++j
            }
        }
        return res
    }

    /**
     * creates a new Uint8Array from current Uint8Array based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint8Array with elements from current Uint8Array that satisfy condition fn
     */
    public filter(fn: (val: number, index: number) => boolean): Uint8Array {
        let newF: (val: number, index: number, array: Uint8Array) => boolean =
            (val: number, index: number, array: Uint8Array): boolean => { return fn(val, index) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number, index: number, array: Uint8Array) => boolean): number | undefined {
        for (let i = 0; i < this.lengthInt; i++) {
            let val = this.getUnsafe(i) as number
            if (predicate(val, i as number, this)) {
                return val
            }
        }
        return undefined
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number, index: number) => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint8Array): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number, index: number, obj: Uint8Array) => boolean): number {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(this.getUnsafe(i) as number, i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number, index: number) => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint8Array): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: () => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint8Array): boolean => predicate())
    }

    /**
     * Finds the last element in the Uint8Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number, index: number, array: Uint8Array) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            let val = this.getUnsafe(i) as number
            if (fn(val, i as number, this)) {
                return val
            }
        }
        throw new Error("Uint8Array.findLast: not implemented if an element was not found")
    }

    /**
     * Finds the last element in the Uint8Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number, index: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint8Array) => boolean =
            (val: number, index: number, array: Uint8Array): boolean => { return fn(val, index) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the Uint8Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number, index: number, array: Uint8Array) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            if (fn(this.getUnsafe(i) as number, i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Finds an index of the last element in the Uint8Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number, index: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint8Array) => boolean =
            (val: number, index: number, array: Uint8Array): boolean => { return fn(val, index) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in Uint8Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: number, index: number, array: Uint8Array) => void): void {
        for (let i = 0; i < this.lengthInt; i++) {
            callbackfn(this.getUnsafe(i) as number, i as number, this)
        }
    }

    /**
     * Performs the specified action for each element in Uint8Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: number, index: number) => void): void {
        this.forEach((value: number, index: number, array: Uint8Array): void => callbackfn(value, index))
    }

    /**
     * Performs the specified action for each element in Uint8Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: () => void): void {
        this.forEach((value: number, index: number, array: Uint8Array): void => callbackfn())
    }

    /**
     * Returns the object itself
     *
     * @returns Uint8Array
     */
    public valueOf(): Uint8Array {
        return this
    }

    /** Byte offset within the underlying Buffer */
    public get byteOffset(): number {
        return this.byteOffsetInt
    }

    /** Number of bytes used */
    public get byteLength(): number {
        return this.byteLengthInt
    }

    /** Number of int stored in Uint8Array */
    public get length(): number {
        return this.lengthInt
    }

    /** String \"Uint8Array\" */
    public readonly name = "Uint8Array"

    private static clamp(val: int): int {
        return val
    }

    internal setUnsafeClamp(insertPos: int, val: int): void {
        this.setUnsafe(insertPos, val)
    }

    internal getUnsafe(index: int): int {
        index = index * Uint8Array.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: int = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint8Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint8Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint8Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + 0 - i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint8Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + 0 - i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
        return res
    }

    internal setUnsafe(index: int, val: int): void {
        index = index * Uint8Array.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: int = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint8Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint8Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint8Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + 0 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint8Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + 0 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
    }
}


class Uint16ArrayIteratorKeys implements IterableIterator<number> {
    private length: int = 0
    private idx: int = 0

    constructor(parent: Uint16Array) {
        this.length = parent.length as int
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<number> {
        if (this.idx < 0 || this.idx >= this.length) {
            return new IteratorResult<number>()
        }
        return new IteratorResult<number>(false, this.idx++ as number)
    }
}

class Uint16ArrayIterator implements IterableIterator<Number> {
    private parent: Uint16Array
    private idx: int = 0

    constructor(parent: Uint16Array) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<Number> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<Number>()
        }
        return new IteratorResult<Number>(false, new Number(this.parent.getUnsafe(this.idx++)))
    }
}

class Uint16ArrayIteratorEntries implements IterableIterator<[Number, Number]> {
    private parent: Uint16Array
    private idx: int = 0

    constructor(parent: Uint16Array) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<[Number, Number]> {
        return this
    }

    override next(): IteratorResult<[Number, Number]> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<[Number, Number]>()
        }
        return new IteratorResult<[Number, Number]>(
            false,
            [new Number(this.idx), new Number(this.parent.getUnsafe(this.idx++))]
        )
    }
}

/**
 * JS Uint16Array API-compatible class
 */
export class Uint16Array implements Iterable<Number>, ArrayLike<Number> {
    public static readonly BYTES_PER_ELEMENT: number = 2

    /** Underlying Buffer */
    public readonly buffer: ArrayBufferLike

    internal readonly byteOffsetInt: int
    internal readonly byteLengthInt: int
    internal readonly lengthInt: int

    /**
     * Creates an empty Uint16Array.
     */
    public constructor() {
        this(0 as int)
    }

    /**
     * Creates an Uint16Array with respect to data accessed via Iterable<Number> interface
     */
    public constructor(elements: Iterable<Number>) {
        // NOTE (ikorobkov): dealing with this overload is tricky
        // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
        let arr = Array.from<Number>(elements)
        this.byteLengthInt = arr.length as int * Uint16Array.BYTES_PER_ELEMENT as int
        this.lengthInt = arr.length as int
        this.buffer = new ArrayBuffer(this.byteLengthInt)
        this.byteOffsetInt = 0
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr.$_get(i).intValue())
        }
    }

    /**
     * Creates an Uint16Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint16Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined, length: Number | undefined) {
        let intByteOffset: int = 0
        if (byteOffset != undefined) {
            intByteOffset = byteOffset.intValue()
            if (intByteOffset < 0) {
                throw new RangeError("Range Error: byteOffset " + intByteOffset + " is outside the bounds of the buffer")
            }
        }
        let intByteLength: int
        if (buf instanceof ArrayBuffer) {
            intByteLength = (buf as ArrayBuffer).getByteLength()
        } else if (buf instanceof SharedArrayBuffer) {
            intByteLength = (buf as SharedArrayBuffer).getByteLength()
        } else {
            throw new Error("unexpected type of ArrayBufferLike")
        }
        intByteLength = intByteLength - intByteOffset
        if (intByteLength < 0) {
            throw new RangeError("Range Error: byteLength " + intByteLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
        }

        if (intByteLength % Uint16Array.BYTES_PER_ELEMENT as int != 0) {
            throw new RangeError("ArrayBufferLike.byteLength should be multiple of 2 as Uint16Array.BYTES_PER_ELEMENT")
        }
        if (intByteOffset % Uint16Array.BYTES_PER_ELEMENT as int != 0) {
            throw new RangeError("byteOffset should be multiple of 2 as Uint16Array.BYTES_PER_ELEMENT")
        }

        let intLength: int
        if (length != undefined) {
            intLength = length.intValue()
            if (intLength > intByteLength / Uint16Array.BYTES_PER_ELEMENT as int) {
                throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
            }
        } else {
            intLength = intByteLength / Uint16Array.BYTES_PER_ELEMENT as int
        }
        if (intLength < 0) {
            throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer")
        }
        if (intLength < intByteLength / Uint16Array.BYTES_PER_ELEMENT as int) {
            intByteLength = intLength * Uint16Array.BYTES_PER_ELEMENT as int
        }
        this.byteLengthInt = intByteLength
        this.byteOffsetInt = intByteOffset
        this.lengthInt = intLength
        this.buffer = buf
    }

    /**
     * Creates an Uint16Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined) {
        this(buf, byteOffset, undefined)
    }

    /**
     * Creates an Uint16Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint16Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number, length: number) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an Uint16Array with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an Uint16Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type int in newly created Uint16Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int, length: int) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an Uint16Array with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an Uint16Array with respect to buf.
     *
     * @param buf data initializer
     */
    public constructor(buf: ArrayLike<Number> | ArrayBufferLike) {
        if (buf instanceof ArrayBuffer) {
            this.byteLengthInt = (buf as ArrayBuffer).getByteLength()
            if (this.byteLengthInt % Uint16Array.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of int as Uint16Array.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / Uint16Array.BYTES_PER_ELEMENT as int
            this.buffer = buf as ArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof SharedArrayBuffer) {
            this.byteLengthInt = (buf as SharedArrayBuffer).getByteLength()
            if (this.byteLengthInt % Uint16Array.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of int as Uint16Array.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / Uint16Array.BYTES_PER_ELEMENT as int
            this.buffer = buf as SharedArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof ArrayLike) {
            // NOTE (ikorobkov): dealing with this overload is tricky
            // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
            let arr = Array.from<Number>((buf as ArrayLike<Number>))
            this.byteLengthInt = arr.length as int * Uint16Array.BYTES_PER_ELEMENT as int
            this.lengthInt = arr.length as int
            this.buffer = new ArrayBuffer(this.byteLengthInt)
            this.byteOffsetInt = 0
            for (let i: int = 0; i < this.lengthInt; ++i) {
                this.setUnsafe(i, arr.$_get(i).intValue())
            }
        } else {
            throw new Error("unexpected type of buf")
        }
    }

    /**
     * Creates an Uint16Array with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: int) {
        if (length < 0) {
            throw new RangeError("Range Error: length " + length + " is outside the bounds of the buffer")
        }
        this.lengthInt = length
        this.byteLengthInt = length * Uint16Array.BYTES_PER_ELEMENT as int
        this.byteOffsetInt = 0
        this.buffer = new ArrayBuffer(this.byteLengthInt)
    }

    /**
     * Creates an Uint16Array with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: number) {
        this(length as int)
    }

    /**
     * Creates a copy of Uint16Array.
     *
     * @param other data initializer
     */
    public constructor(other: Uint16Array) {
        if (other.buffer instanceof ArrayBuffer) {
            this.buffer = (other.buffer as ArrayBuffer).slice(0 as int, other.byteLength as int) as ArrayBuffer
        } else if (other.buffer instanceof SharedArrayBuffer) {
            this.buffer = (other.buffer as SharedArrayBuffer).slice(0 as int, other.byteLength as int) as SharedArrayBuffer
        } else {
            throw new Error("unexpected type of buffer")
        }
        this.byteLengthInt = other.byteLength as int
        this.lengthInt = other.length as int
        this.byteOffsetInt = 0
    }

    /**
     * Creates an Uint16Array from number[]
     */
    public constructor(numbers: number[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, this.zeroIfInfinity(numbers[i]) as int)
        }
    }

    /**
     * Creates an Uint16Array from int[]
     */
    public constructor(numbers: int[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, this.zeroIfInfinity(numbers[i]) as int)
        }
    }

    internal zeroIfInfinity(val: number): number {
        if ((val == Infinity) || (val == -Infinity)) {
            return 0 as number
        }
        return val as number
    }

    internal zeroIfInfinity(val: int): int {
        if ((val == Infinity) || (val == -Infinity)) {
            return 0 as int
        }
        return val
    }

    /**
     * Iteratorable interface implementation
     *
     * @returns iterator over all elements
     */
    public override $_iterator(): IterableIterator<Number> {
         return this.values()
    }

    /**
     * Returns an instance of primitive type at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: number): Number | undefined {
        return this.at(index as int)
    }

    /**
     * Returns an instance of primitive type at passed index if index is correct.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: int): Number | undefined {
        let k: int
        if (index >= 0) {
            k = index
        } else {
            k = this.lengthInt + index
        }
        if (k < 0 || k >= this.lengthInt) {
            return undefined
        }
        return new Number(this.getUnsafe(k))
    }

    /**
     * Returns an instance of number at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public override $_get(index: number): Number {
        return this.$_get(index as int) as Number
    }

    /**
     * Returns an instance of number at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public $_get(i: int): number {
        if (i < 0 || i >= this.lengthInt) {
            throw new RangeError("invalid offset")
        }
        return this.getUnsafe(i) as number
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: number): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: number): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val)
        this.setUnsafeClamp(index, v as int)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: int): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: int): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val)
        this.setUnsafeClamp(index, v)
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: number, end?: number): Uint16Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: number, end?: number): Uint16Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: int, end?: number): Uint16Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end?: number): Uint16Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param insert insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end: int): Uint16Array {
        let toPos = normalizeIndex(target, this.lengthInt)
        let fromPos = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        let count: int = finalPos - fromPos
        if (count > (this.lengthInt - toPos)) {
            count = this.lengthInt - toPos
        }
        let direction: int = 1
        if ((fromPos < toPos) && (toPos < fromPos + count)) {
            fromPos = fromPos + count - 1
            toPos   = toPos   + count - 1
            direction = -1
        }
        while (count > 0) {
            const value = this.getUnsafe(fromPos)
            this.setUnsafe(toPos, value)
            fromPos = fromPos + direction
            toPos = toPos + direction
            --count
        }
        return this
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of Uint16Array.
     *
     * @param target insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: number): Uint16Array {
        return this.copyWithin(target as int)
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of Uint16Array.
     *
     * @param insert insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: int): Uint16Array {
        return this.copyWithin(target, 0, this.lengthInt)
    }

    /**
     * Returns an array of key, value pairs for every entry in the Uint16Array
     *
     * @returns key, value pairs for every entry in the array
     */
    public entries(): IterableIterator<[Number, Number]> {
        return new Uint16ArrayIteratorEntries(this)
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: number, start?: number, end?: number): Uint16Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: number, start: int, end?: number): Uint16Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: number, start: int, end: number): Uint16Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: number, start: number, end: int): Uint16Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: number, start: int, end: int): Uint16Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as int, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: int, start?: number, end?: number): Uint16Array {
        this.fill(value, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: int, start: int, end?: number): Uint16Array {
        this.fill(value, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: int, start: int, end: number): Uint16Array {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: int, start: number, end: int): Uint16Array {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint16Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint16Array
     */
    public fill(value: int, start: int, end: int): Uint16Array {
        const k = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        for (let i: int = k; i < finalPos; ++i) {
            this.setUnsafe(i, value)
        }
        return this
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: number): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: number): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: int): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: int): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Copies all elements of arr to the current Uint16Array starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: number[], insertPos1: number): void {
        const insertPos = insertPos1 as int
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: int[]): size of arr is greater than Uint16Array.length")
        }
        for (let i = 0; i < arr.length; i++) {
            let v = this.zeroIfInfinity(arr[i])
            this.setUnsafeClamp(insertPos as int + i as int, v as int)
        }
    }

    /**
     * Copies all elements of arr to the current Uint16Array starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: int[], insertPos: int): void {
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: int[]): size of arr is greater than Uint16Array.length")
        }
        for (let i = 0; i < arr.length; i++) {
            let v = this.zeroIfInfinity(arr[i])
            this.setUnsafeClamp(insertPos + i, v)
        }
    }

    /**
     * Copies all elements of arr to the current Uint16Array.
     *
     * @param arr array to copy data from
     */
    public set(arr: number[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies all elements of arr to the current Uint16Array.
     *
     * @param arr array to copy data from
     */
    public set(arr: int[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies elements from an ArrayLike object to the Uint16Array.
     *
     * @param array An ArrayLike object containing the elements to copy.
     *
     * @param offset Optional. The offset into the target array at which to begin writing values from the source array
     */
    public set(array: ArrayLike<number>, offset: number = 0): void {
        const insertPos = offset as int
        if (insertPos < 0 || insertPos + array.length > this.lengthInt) {
            throw new RangeError("offset is out of bounds")
        }
        for (let i = 0; i < array.length; i++) {
            let v = this.zeroIfInfinity(array[i])
            this.setUnsafeClamp(insertPos as int + i as int, v as int)
        }
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint16Array
     */
    public static of(...items: number[]): Uint16Array {
        let res = new Uint16Array(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, res.zeroIfInfinity(items[i]) as int)
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint16Array
     */
    public static of(...items: int[]): Uint16Array {
        let res = new Uint16Array(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, items[i])
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint16Array
     */
    public static of(): Uint16Array {
        return new Uint16Array(0 as int)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @returns new Uint16Array
     */
    public static from(arr: ArrayLike<number>): Uint16Array {
        return Uint16Array.from<number>(arr, (x: number, k: number): number => x)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new Uint16Array
     */
    public static from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number): Uint16Array {
        if (mapfn == undefined) {
            mapfn = (v: number, k: number): number => { return v }
        }
        // Calc length of items inside arrayLike, save length into i variable
        let i: long = 0
        let iter = arrayLike.$_iterator()
        while (true) {
            const v = iter.next()
            if (v.done) {
                break
            }
            i++
        }

        let res = new Uint16Array(i as int)
        i = 0
        iter = arrayLike.$_iterator()
        while (true) {
            const v = iter.next()
            if (v.done) {
                return res
            }
            res.setUnsafeClamp(i as int, res.zeroIfInfinity((mapfn)!(v.value as number, i as number)) as int)
            i++
        }
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new Uint16Array
     */
    public static from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number): Uint16Array {
        let res = new Uint16Array(arrayLike.length)
        // NOTE (ikorobkov): Please don't replace idx as int[1] with int-variable, because of value of single variable doesn't change (idx++) into lambda call by unknown reason
        const idx = new int[1]
        idx[0] = 0
        iteratorForEach<T>(arrayLike.$_iterator(), (x: T): void => {
            res.setUnsafeClamp(idx[0], res.zeroIfInfinity(mapfn(x as T, idx[0] as number)) as int)
            idx[0] += 1
        })
        return res
    }

    /**
     * Determines whether Uint16Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint16Array, false otherwise
     */
    public includes(searchElement: number, fromIndex?: number): boolean {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0)) != -1
    }

    /**
     * Determines whether Uint16Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint16Array, false otherwise
     */
    public includes(searchElement: int, fromIndex: int): boolean {
        return this.indexOf(searchElement as int, fromIndex) != -1
    }

    /**
     * Determines whether Uint16Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint16Array, false otherwise
     */
    public includes(searchElement: int): boolean {
        return this.indexOf(searchElement as int, 0) != -1
    }

    /**
     * Returns the index of the first occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: number, fromIndex?: number): number {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the first occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: number, fromIndex: int): number {
        if (isNaN(searchElement)) {
            return -1
        }
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) as number == searchElement) {
                return i
            }
        }
        return -1
    }

    /**
     * Returns the index of the first occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int, fromIndex: int): number {
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) == searchElement) {
                return i
            }
        }
        return -1

    }

    /**
     * Returns the index of the first occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int): number {
        return this.indexOf(searchElement, 0)
    }

    /**
     * Adds all the elements of an array separated by the specified separator string
     *
     * @param separator A string used to separate one element of an array from the next in the
     * resulting String. If omitted, the array elements are separated with a comma
     *
     * @returns joined representation
     */
    public join(separator?: String): string {
        if (separator == undefined) {
            return this.join(",")
        }
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; i++) {
            res.append(this.getUnsafe(i) as number)
            res.append(separator)
        }
        if (this.lengthInt > 0) {
            res.append(this.getUnsafe(this.lengthInt - 1) as number)
        }
        return res.toString()
    }

    /**
     * Returns an list of keys in Uint16Array
     *
     * @returns iterator over keys
     */
    public keys(): IterableIterator<number> {
        return new Uint16ArrayIteratorKeys(this)
    }

    /**
     * Returns the index of the last occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number, fromIndex: number|undefined): number {
        return this.lastIndexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the last occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

    /**
     * Returns the index of the last occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number, fromIndex: int): number {
        if (isNaN(searchElement)) {
            return -1
        }
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) as number == searchElement) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int, fromIndex: int): number {
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) == searchElement) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in Uint16Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

   /**
    * Creates a new Uint16Array using initializer
    *
    * @param data initializer
    *
    * @returns a new Uint16Array from data
    */
    public of(...data: number[]): Uint16Array {
        throw new Error("Uint16Array.of: not implemented")
    }

    /**
     * Creates a new Uint16Array using reversed data from the current one
     *
     * @returns a new Uint16Array using reversed data from the current one
     */
    public reverse(): Uint16Array {
        for (let i: int = 0; i < this.lengthInt / 2 as int; i++) {
            const tmp = this.getUnsafe(this.lengthInt - 1 - i)
            this.setUnsafe(this.lengthInt - 1 - i, this.getUnsafe(i))
            this.setUnsafe(i, tmp)
        }
        return this
    }

    /**
     * Creates a slice of current Uint16Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint16Array with elements of current Uint16Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin?: number, end?: number): Uint16Array {
        return this.slice(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a slice of current Uint16Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint16Array with elements of current Uint16Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: number): Uint16Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint16Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint16Array with elements of current Uint16Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: int): Uint16Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint16Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint16Array with elements of current Uint16Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: number): Uint16Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint16Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint16Array with elements of current Uint16Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: int): Uint16Array {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        if (this.buffer instanceof ArrayBuffer) {
            let buf = (this.buffer as ArrayBuffer).slice(relStart * Uint16Array.BYTES_PER_ELEMENT as int, relEnd * Uint16Array.BYTES_PER_ELEMENT as int) as ArrayBuffer
            return new Uint16Array(buf)
        } else if (this.buffer instanceof SharedArrayBuffer) {
            let buf = (this.buffer as SharedArrayBuffer).slice(relStart * Uint16Array.BYTES_PER_ELEMENT as int, relEnd * Uint16Array.BYTES_PER_ELEMENT as int) as SharedArrayBuffer
            return new Uint16Array(buf)
        } else {
            throw new Error("unexpected type of buffer")
        }
    }

    /**
     * Creates a slice of current Uint16Array using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new Uint16Array with elements of current Uint16Array[begin, this.lengthInt)
     */
    public slice(begin: number): Uint16Array {
        return this.slice(begin as int)
    }

    /**
     * Creates a slice of current Uint16Array using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new Uint16Array with elements of current Uint16Array[begin, this.lengthInt)
     */
    public slice(begin: int): Uint16Array {
        return this.slice(begin, this.lengthInt)
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     * If omitted, the elements are sorted in ascending order.
     *
     * @returns sorted Uint16Array
     */
    public sort(compareFn?: (a: number, b: number) => number): this {
        let arr: int[] = new int[this.lengthInt]
        for (let i = 0; i < this.lengthInt; ++i) {
            arr[i] = this.getUnsafe(i)
        }
        let cmp = (l: int, r: int): number => {
                return (l - r) as number
            }
        if (compareFn != undefined) {
            cmp = (l: int, r: int): number => {
                return compareFn!(l as number, r as number)
            }
        }
        sort(arr, cmp)
        for (let i = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr[i])
        }
        return this
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted Uint16Array
     */
    public sort(compareFn: (a: number) => number): this {
        let cmp = (a: number, b: number) => { return compareFn(a)}
        this.sort(cmp)
        return this
    }

    /**
     * Sorts in-place
     *
     * @param fn compareFn —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted Uint16Array
     */
    public sort(compareFn: () => number): this {
        let cmp = (a: number, b: number) => { return compareFn()}
        this.sort(cmp)
        return this
    }
    /**
     * Creates a Uint16Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint16Array with the same underlying Buffer
     */
    public subarray(begin?: number, end?: number): Uint16Array {
        return this.subarray(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a Uint16Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint16Array with the same underlying Buffer
     */
    public subarray(begin: number, end: number): Uint16Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint16Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint16Array with the same underlying Buffer
     */
    public subarray(begin: number, end: int): Uint16Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint16Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint16Array with the same underlying Buffer
     */
    public subarray(begin: int, end: number): Uint16Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint16Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint16Array with the same underlying Buffer
     */
    public subarray(begin: int, end: int): Uint16Array {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        return new Uint16Array(this.buffer, relStart * Uint16Array.BYTES_PER_ELEMENT as int, count)
    }

    /**
     * Creates a Uint16Array with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new Uint16Array with the same Buffer
     */
    public subarray(begin: number): Uint16Array {
        return this.subarray(begin as int, this.lengthInt)
    }

    /**
     * Creates a Uint16Array with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new Uint16Array with the same Buffer
     */
    public subarray(begin: int): Uint16Array {
        return this.subarray(begin, this.lengthInt)
    }

    /**
     * Converts Uint16Array to a string with respect to locale
     *
     * @param locales
     *
     * @param options
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object, options: Object): string {
        throw new Error("Uint16Array.toLocaleString: not implemented")
    }

    /**
     * Converts Uint16Array to a string with respect to locale
     *
     * @param locales
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object): string {
        return this.toLocaleString(new Object(), new Object())
    }

    /**
     * Converts Uint16Array to a string with respect to locale
     *
     * @returns string representation
     */
    public toLocaleString(): string {
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; ++i) {
            res.append((this.getUnsafe(i) as Number).toLocaleString())
            res.append(",")
        }
        if (this.lengthInt > 0) {
            res.append((this.getUnsafe(this.lengthInt - 1) as Number).toLocaleString())
        }
        return res.toString()
    }

    /**
     * Creates a reversed copy
     *
     * @returns a reversed copy
     */
    public toReversed(): Uint16Array {
        return new Uint16Array(this).reverse()
    }

    /**
     * Creates a sorted copy
     *
     * @returns a sorted copy
     */
    public toSorted(): Uint16Array {
        return new Uint16Array(this).sort()
    }

    /**
     * Returns a string representation of the Uint16Array
     *
     * @returns a string representation of the Uint16Array
     */
    public override toString(): string {
        return this.join(",")
    }

    /**
     * Returns array values iterator
     *
     * @returns an iterator
     */
    public values(): IterableIterator<Number> {
         return new Uint16ArrayIterator(this)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an Uint16Array with replaced value on index
     */
    public with(index: number, value: number): Uint16Array {
        return this.with(index as int, value as int)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an Uint16Array with replaced value on index
     */
    /* public */ internal with(index: int, value: int): Uint16Array {
        let res = new Uint16Array(this)
        res.setUnsafeClamp(index, value)
        return res
    }

    /// === with element lambda functions ===

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts one argument.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number) => boolean): boolean {
        return this.every((element: number, index: number, array: Uint16Array): boolean => predicate(element))
    }

    /**
     * creates a new Uint16Array from current Uint16Array based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint16Array with elements from current Uint16Array that satisfy condition fn
     */
    public filter(fn: (val: number) => boolean): Uint16Array {
        let newF: (val: number, index: number, array: Uint16Array) => boolean =
            (val: number, index: number, array: Uint16Array): boolean => { return fn(val) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: () => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint16Array): boolean => predicate())
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number) => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint16Array): boolean => predicate(value))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number) => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint16Array): boolean => predicate(value)) as number
    }

    /**
     * Finds the last element in the Uint16Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint16Array) => boolean =
            (val: number, index: number, array: Uint16Array): boolean => { return fn(val) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the Uint16Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint16Array) => boolean =
            (val: number, index: number, array: Uint16Array): boolean => { return fn(val) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in Uint16Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (val: number) => void): void {
        this.forEach((value: number, index: number, array: Uint16Array): void => callbackfn(value))
    }

    /**
     * Creates a new Uint16Array using fn(arr[i]) over all elements of current Uint16Array
     *
     * @param fn a function to apply for each element of current Uint16Array
     *
     * @returns a new Uint16Array where for each element from current Uint16Array fn was applied
     */
    public map(fn: (val: number) => number): Uint16Array {
        let newF: (val: number, index: number) => number =
            (val: number, index: number): number => { return fn(val) }
        return this.map(newF)
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts one argument.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number) => boolean): boolean {
        return this.some((element: number, index: number, array: Uint16Array): boolean => predicate(element))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number, index: number, array: Uint16Array) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(this.getUnsafe(i) as number, i as number, this)) {
                return true
            }
        }
        return false
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number, index: number) => boolean): boolean {
        return this.some((element: number, index: number, array: Uint16Array): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: () => boolean): boolean {
        return this.some((element: number, index: number, array: Uint16Array): boolean => predicate())
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = 0; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue = this.$_get(0) as number
        for (let i = 1; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal, currVal, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal, currVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: () => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn())
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U, currentValue: number, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U, currentValue: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue: number = this.$_get(this.lengthInt - 1) as number
        for (let i = this.lengthInt - 2; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevValue, currValue, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevValue, currValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint16Array) =>
                        callbackfn(prevValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: () => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint16Array) =>
                        callbackfn())
    }

    /**
     * Creates a new Uint16Array using fn(arr[i]) over all elements of current Uint16Array.
     *
     * @param fn a function to apply for each element of current Uint16Array
     *
     * @returns a new Uint16Array where for each element from current Uint16Array fn was applied
     */
    public map(fn: (val: number, index: number) => number): Uint16Array {
        let resBuf = new ArrayBuffer(this.lengthInt * Uint16Array.BYTES_PER_ELEMENT as int)
        let res = new Uint16Array(resBuf)
        for (let i = 0; i < this.lengthInt; i++) {
            const fnRes = fn(this.getUnsafe(i) as number, i as number)
            res.setUnsafeClamp(i, fnRes as int)
        }
        return res
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number, index: number, array: Uint16Array) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (!predicate(this.getUnsafe(i) as number, i as number, this)) {
                return false
            }
        }
        return true
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number, index: number) => boolean): boolean {
        return this.every((element: number, index: number, array: Uint16Array): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: () => boolean): boolean {
        return this.every((element: number, index: number, array: Uint16Array): boolean => predicate())
    }

    /**
     * Creates a new Uint16Array from current Uint16Array based on a condition fn.
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint16Array with elements from current Uint16Array that satisfy condition fn
     */
    public filter(fn: (val: number, index: number, array: Uint16Array) => boolean): Uint16Array {
        let markers = new boolean[this.lengthInt]
        let resLen = 0
        for (let i = 0; i < this.lengthInt; i++) {
            markers[i] = fn(this.getUnsafe(i) as number, i as number, this)
            if (markers[i]) {
                ++resLen
            }
        }
        let res = new Uint16Array(resLen)
        for (let i = 0, j = 0; i < this.lengthInt; i++) {
            if (markers[i]) {
                res.setUnsafe(j, this.getUnsafe(i))
                ++j
            }
        }
        return res
    }

    /**
     * creates a new Uint16Array from current Uint16Array based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint16Array with elements from current Uint16Array that satisfy condition fn
     */
    public filter(fn: (val: number, index: number) => boolean): Uint16Array {
        let newF: (val: number, index: number, array: Uint16Array) => boolean =
            (val: number, index: number, array: Uint16Array): boolean => { return fn(val, index) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number, index: number, array: Uint16Array) => boolean): number | undefined {
        for (let i = 0; i < this.lengthInt; i++) {
            let val = this.getUnsafe(i) as number
            if (predicate(val, i as number, this)) {
                return val
            }
        }
        return undefined
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number, index: number) => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint16Array): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number, index: number, obj: Uint16Array) => boolean): number {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(this.getUnsafe(i) as number, i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number, index: number) => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint16Array): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: () => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint16Array): boolean => predicate())
    }

    /**
     * Finds the last element in the Uint16Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number, index: number, array: Uint16Array) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            let val = this.getUnsafe(i) as number
            if (fn(val, i as number, this)) {
                return val
            }
        }
        throw new Error("Uint16Array.findLast: not implemented if an element was not found")
    }

    /**
     * Finds the last element in the Uint16Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number, index: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint16Array) => boolean =
            (val: number, index: number, array: Uint16Array): boolean => { return fn(val, index) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the Uint16Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number, index: number, array: Uint16Array) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            if (fn(this.getUnsafe(i) as number, i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Finds an index of the last element in the Uint16Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number, index: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint16Array) => boolean =
            (val: number, index: number, array: Uint16Array): boolean => { return fn(val, index) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in Uint16Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: number, index: number, array: Uint16Array) => void): void {
        for (let i = 0; i < this.lengthInt; i++) {
            callbackfn(this.getUnsafe(i) as number, i as number, this)
        }
    }

    /**
     * Performs the specified action for each element in Uint16Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: number, index: number) => void): void {
        this.forEach((value: number, index: number, array: Uint16Array): void => callbackfn(value, index))
    }

    /**
     * Performs the specified action for each element in Uint16Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: () => void): void {
        this.forEach((value: number, index: number, array: Uint16Array): void => callbackfn())
    }

    /**
     * Returns the object itself
     *
     * @returns Uint16Array
     */
    public valueOf(): Uint16Array {
        return this
    }

    /** Byte offset within the underlying Buffer */
    public get byteOffset(): number {
        return this.byteOffsetInt
    }

    /** Number of bytes used */
    public get byteLength(): number {
        return this.byteLengthInt
    }

    /** Number of int stored in Uint16Array */
    public get length(): number {
        return this.lengthInt
    }

    /** String \"Uint16Array\" */
    public readonly name = "Uint16Array"

    private static clamp(val: int): int {
        return val
    }

    internal setUnsafeClamp(insertPos: int, val: int): void {
        this.setUnsafe(insertPos, val)
    }

    internal getUnsafe(index: int): int {
        index = index * Uint16Array.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: int = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint16Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint16Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint16Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + 1 - i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint16Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + 1 - i) as int
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
        return res
    }

    internal setUnsafe(index: int, val: int): void {
        index = index * Uint16Array.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: int = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint16Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint16Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint16Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + 1 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint16Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + 1 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
    }
}


class Uint32ArrayIteratorKeys implements IterableIterator<number> {
    private length: int = 0
    private idx: int = 0

    constructor(parent: Uint32Array) {
        this.length = parent.length as int
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<number> {
        if (this.idx < 0 || this.idx >= this.length) {
            return new IteratorResult<number>()
        }
        return new IteratorResult<number>(false, this.idx++ as number)
    }
}

class Uint32ArrayIterator implements IterableIterator<Number> {
    private parent: Uint32Array
    private idx: int = 0

    constructor(parent: Uint32Array) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<Number> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<Number>()
        }
        return new IteratorResult<Number>(false, new Number(this.parent.getUnsafe(this.idx++)))
    }
}

class Uint32ArrayIteratorEntries implements IterableIterator<[Number, Number]> {
    private parent: Uint32Array
    private idx: int = 0

    constructor(parent: Uint32Array) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<[Number, Number]> {
        return this
    }

    override next(): IteratorResult<[Number, Number]> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<[Number, Number]>()
        }
        return new IteratorResult<[Number, Number]>(
            false,
            [new Number(this.idx), new Number(this.parent.getUnsafe(this.idx++))]
        )
    }
}

/**
 * JS Uint32Array API-compatible class
 */
export class Uint32Array implements Iterable<Number>, ArrayLike<Number> {
    public static readonly BYTES_PER_ELEMENT: number = 4

    /** Underlying Buffer */
    public readonly buffer: ArrayBufferLike

    internal readonly byteOffsetInt: int
    internal readonly byteLengthInt: int
    internal readonly lengthInt: int

    /**
     * Creates an empty Uint32Array.
     */
    public constructor() {
        this(0 as int)
    }

    /**
     * Creates an Uint32Array with respect to data accessed via Iterable<Number> interface
     */
    public constructor(elements: Iterable<Number>) {
        // NOTE (ikorobkov): dealing with this overload is tricky
        // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
        let arr = Array.from<Number>(elements)
        this.byteLengthInt = arr.length as int * Uint32Array.BYTES_PER_ELEMENT as int
        this.lengthInt = arr.length as int
        this.buffer = new ArrayBuffer(this.byteLengthInt)
        this.byteOffsetInt = 0
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr.$_get(i).longValue())
        }
    }

    /**
     * Creates an Uint32Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type long in newly created Uint32Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined, length: Number | undefined) {
        let intByteOffset: int = 0
        if (byteOffset != undefined) {
            intByteOffset = byteOffset.intValue()
            if (intByteOffset < 0) {
                throw new RangeError("Range Error: byteOffset " + intByteOffset + " is outside the bounds of the buffer")
            }
        }
        let intByteLength: int
        if (buf instanceof ArrayBuffer) {
            intByteLength = (buf as ArrayBuffer).getByteLength()
        } else if (buf instanceof SharedArrayBuffer) {
            intByteLength = (buf as SharedArrayBuffer).getByteLength()
        } else {
            throw new Error("unexpected type of ArrayBufferLike")
        }
        intByteLength = intByteLength - intByteOffset
        if (intByteLength < 0) {
            throw new RangeError("Range Error: byteLength " + intByteLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
        }

        if (intByteLength % Uint32Array.BYTES_PER_ELEMENT as int != 0) {
            throw new RangeError("ArrayBufferLike.byteLength should be multiple of 4 as Uint32Array.BYTES_PER_ELEMENT")
        }
        if (intByteOffset % Uint32Array.BYTES_PER_ELEMENT as int != 0) {
            throw new RangeError("byteOffset should be multiple of 4 as Uint32Array.BYTES_PER_ELEMENT")
        }

        let intLength: int
        if (length != undefined) {
            intLength = length.intValue()
            if (intLength > intByteLength / Uint32Array.BYTES_PER_ELEMENT as int) {
                throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
            }
        } else {
            intLength = intByteLength / Uint32Array.BYTES_PER_ELEMENT as int
        }
        if (intLength < 0) {
            throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer")
        }
        if (intLength < intByteLength / Uint32Array.BYTES_PER_ELEMENT as int) {
            intByteLength = intLength * Uint32Array.BYTES_PER_ELEMENT as int
        }
        this.byteLengthInt = intByteLength
        this.byteOffsetInt = intByteOffset
        this.lengthInt = intLength
        this.buffer = buf
    }

    /**
     * Creates an Uint32Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined) {
        this(buf, byteOffset, undefined)
    }

    /**
     * Creates an Uint32Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type long in newly created Uint32Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number, length: number) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an Uint32Array with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an Uint32Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type long in newly created Uint32Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int, length: int) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an Uint32Array with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an Uint32Array with respect to buf.
     *
     * @param buf data initializer
     */
    public constructor(buf: ArrayLike<Number> | ArrayBufferLike) {
        if (buf instanceof ArrayBuffer) {
            this.byteLengthInt = (buf as ArrayBuffer).getByteLength()
            if (this.byteLengthInt % Uint32Array.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of long as Uint32Array.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / Uint32Array.BYTES_PER_ELEMENT as int
            this.buffer = buf as ArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof SharedArrayBuffer) {
            this.byteLengthInt = (buf as SharedArrayBuffer).getByteLength()
            if (this.byteLengthInt % Uint32Array.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of long as Uint32Array.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / Uint32Array.BYTES_PER_ELEMENT as int
            this.buffer = buf as SharedArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof ArrayLike) {
            // NOTE (ikorobkov): dealing with this overload is tricky
            // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
            let arr = Array.from<Number>((buf as ArrayLike<Number>))
            this.byteLengthInt = arr.length as int * Uint32Array.BYTES_PER_ELEMENT as int
            this.lengthInt = arr.length as int
            this.buffer = new ArrayBuffer(this.byteLengthInt)
            this.byteOffsetInt = 0
            for (let i: int = 0; i < this.lengthInt; ++i) {
                this.setUnsafe(i, arr.$_get(i).longValue())
            }
        } else {
            throw new Error("unexpected type of buf")
        }
    }

    /**
     * Creates an Uint32Array with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: int) {
        if (length < 0) {
            throw new RangeError("Range Error: length " + length + " is outside the bounds of the buffer")
        }
        this.lengthInt = length
        this.byteLengthInt = length * Uint32Array.BYTES_PER_ELEMENT as int
        this.byteOffsetInt = 0
        this.buffer = new ArrayBuffer(this.byteLengthInt)
    }

    /**
     * Creates an Uint32Array with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: number) {
        this(length as int)
    }

    /**
     * Creates a copy of Uint32Array.
     *
     * @param other data initializer
     */
    public constructor(other: Uint32Array) {
        if (other.buffer instanceof ArrayBuffer) {
            this.buffer = (other.buffer as ArrayBuffer).slice(0 as int, other.byteLength as int) as ArrayBuffer
        } else if (other.buffer instanceof SharedArrayBuffer) {
            this.buffer = (other.buffer as SharedArrayBuffer).slice(0 as int, other.byteLength as int) as SharedArrayBuffer
        } else {
            throw new Error("unexpected type of buffer")
        }
        this.byteLengthInt = other.byteLength as int
        this.lengthInt = other.length as int
        this.byteOffsetInt = 0
    }

    /**
     * Creates an Uint32Array from number[]
     */
    public constructor(numbers: number[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, this.zeroIfInfinity(numbers[i]) as long)
        }
    }

    /**
     * Creates an Uint32Array from int[]
     */
    public constructor(numbers: int[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, this.zeroIfInfinity(numbers[i]) as long)
        }
    }

    internal zeroIfInfinity(val: number): number {
        if ((val == Infinity) || (val == -Infinity)) {
            return 0 as number
        }
        return val as number
    }

    internal zeroIfInfinity(val: long): long {
        if ((val == Infinity) || (val == -Infinity)) {
            return 0 as long
        }
        return val
    }

    /**
     * Iteratorable interface implementation
     *
     * @returns iterator over all elements
     */
    public override $_iterator(): IterableIterator<Number> {
         return this.values()
    }

    /**
     * Returns an instance of primitive type at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: number): Number | undefined {
        return this.at(index as int)
    }

    /**
     * Returns an instance of primitive type at passed index if index is correct.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: int): Number | undefined {
        let k: int
        if (index >= 0) {
            k = index
        } else {
            k = this.lengthInt + index
        }
        if (k < 0 || k >= this.lengthInt) {
            return undefined
        }
        return new Number(this.getUnsafe(k))
    }

    /**
     * Returns an instance of number at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public override $_get(index: number): Number {
        return this.$_get(index as int) as Number
    }

    /**
     * Returns an instance of number at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public $_get(i: int): number {
        if (i < 0 || i >= this.lengthInt) {
            throw new RangeError("invalid offset")
        }
        return this.getUnsafe(i) as number
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: number): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: number): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val)
        this.setUnsafeClamp(index, v as long)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: long): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: long): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val)
        this.setUnsafeClamp(index, v)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: int): void {
        this.$_set(index as int, val as int)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: int): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val as long)
        this.setUnsafeClamp(index, v)
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: number, end?: number): Uint32Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: number, end?: number): Uint32Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: int, end?: number): Uint32Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end?: number): Uint32Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param insert insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end: int): Uint32Array {
        let toPos = normalizeIndex(target, this.lengthInt)
        let fromPos = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        let count: int = finalPos - fromPos
        if (count > (this.lengthInt - toPos)) {
            count = this.lengthInt - toPos
        }
        let direction: int = 1
        if ((fromPos < toPos) && (toPos < fromPos + count)) {
            fromPos = fromPos + count - 1
            toPos   = toPos   + count - 1
            direction = -1
        }
        while (count > 0) {
            const value = this.getUnsafe(fromPos)
            this.setUnsafe(toPos, value)
            fromPos = fromPos + direction
            toPos = toPos + direction
            --count
        }
        return this
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of Uint32Array.
     *
     * @param target insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: number): Uint32Array {
        return this.copyWithin(target as int)
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of Uint32Array.
     *
     * @param insert insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: int): Uint32Array {
        return this.copyWithin(target, 0, this.lengthInt)
    }

    /**
     * Returns an array of key, value pairs for every entry in the Uint32Array
     *
     * @returns key, value pairs for every entry in the array
     */
    public entries(): IterableIterator<[Number, Number]> {
        return new Uint32ArrayIteratorEntries(this)
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: number, start?: number, end?: number): Uint32Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as long, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: number, start: int, end?: number): Uint32Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as long, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: number, start: int, end: number): Uint32Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as long, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: number, start: number, end: int): Uint32Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as long, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: number, start: int, end: int): Uint32Array {
        value = this.zeroIfInfinity(value)
        this.fill(value as long, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: long, start?: number, end?: number): Uint32Array {
        this.fill(value, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: long, start: int, end?: number): Uint32Array {
        this.fill(value, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: long, start: int, end: number): Uint32Array {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: long, start: number, end: int): Uint32Array {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the Uint32Array with specified value
     *
     * @param value new value
     *
     * @returns modified Uint32Array
     */
    public fill(value: long, start: int, end: int): Uint32Array {
        const k = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        for (let i: int = k; i < finalPos; ++i) {
            this.setUnsafe(i, value)
        }
        return this
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: number): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: number): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: long): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: long): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Copies all elements of arr to the current Uint32Array starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: number[], insertPos1: number): void {
        const insertPos = insertPos1 as int
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: long[]): size of arr is greater than Uint32Array.length")
        }
        for (let i = 0; i < arr.length; i++) {
            let v = this.zeroIfInfinity(arr[i])
            this.setUnsafeClamp(insertPos as int + i as int, v as long)
        }
    }

    /**
     * Copies all elements of arr to the current Uint32Array starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: long[], insertPos: int): void {
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: long[]): size of arr is greater than Uint32Array.length")
        }
        for (let i = 0; i < arr.length; i++) {
            let v = this.zeroIfInfinity(arr[i])
            this.setUnsafeClamp(insertPos + i, v)
        }
    }

    /**
     * Copies all elements of arr to the current Uint32Array.
     *
     * @param arr array to copy data from
     */
    public set(arr: number[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies all elements of arr to the current Uint32Array.
     *
     * @param arr array to copy data from
     */
    public set(arr: long[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies elements from an ArrayLike object to the Uint32Array.
     *
     * @param array An ArrayLike object containing the elements to copy.
     *
     * @param offset Optional. The offset into the target array at which to begin writing values from the source array
     */
    public set(array: ArrayLike<number>, offset: number = 0): void {
        const insertPos = offset as int
        if (insertPos < 0 || insertPos + array.length > this.lengthInt) {
            throw new RangeError("offset is out of bounds")
        }
        for (let i = 0; i < array.length; i++) {
            let v = this.zeroIfInfinity(array[i])
            this.setUnsafeClamp(insertPos as int + i as int, v as long)
        }
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint32Array
     */
    public static of(...items: number[]): Uint32Array {
        let res = new Uint32Array(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, res.zeroIfInfinity(items[i]) as long)
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint32Array
     */
    public static of(...items: int[]): Uint32Array {
        let res = new Uint32Array(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, items[i] as long)
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint32Array
     */
    public static of(...items: long[]): Uint32Array {
        let res = new Uint32Array(items.length as int)
        for (let i: int = 0; i < items.length; i++) {
            res.setUnsafeClamp(i, items[i])
        }
        return res
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new Uint32Array
     */
    public static of(): Uint32Array {
        return new Uint32Array(0 as int)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @returns new Uint32Array
     */
    public static from(arr: ArrayLike<number>): Uint32Array {
        return Uint32Array.from<number>(arr, (x: number, k: number): number => x)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new Uint32Array
     */
    public static from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number): Uint32Array {
        if (mapfn == undefined) {
            mapfn = (v: number, k: number): number => { return v }
        }
        // Calc length of items inside arrayLike, save length into i variable
        let i: long = 0
        let iter = arrayLike.$_iterator()
        while (true) {
            const v = iter.next()
            if (v.done) {
                break
            }
            i++
        }

        let res = new Uint32Array(i as int)
        i = 0
        iter = arrayLike.$_iterator()
        while (true) {
            const v = iter.next()
            if (v.done) {
                return res
            }
            res.setUnsafeClamp(i as int, res.zeroIfInfinity((mapfn)!(v.value as number, i as number)) as long)
            i++
        }
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new Uint32Array
     */
    public static from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number): Uint32Array {
        let res = new Uint32Array(arrayLike.length)
        // NOTE (ikorobkov): Please don't replace idx as int[1] with int-variable, because of value of single variable doesn't change (idx++) into lambda call by unknown reason
        const idx = new int[1]
        idx[0] = 0
        iteratorForEach<T>(arrayLike.$_iterator(), (x: T): void => {
            res.setUnsafeClamp(idx[0], res.zeroIfInfinity(mapfn(x as T, idx[0] as number)) as long)
            idx[0] += 1
        })
        return res
    }

    /**
     * Determines whether Uint32Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint32Array, false otherwise
     */
    public includes(searchElement: number, fromIndex?: number): boolean {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0)) != -1
    }

    /**
     * Determines whether Uint32Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint32Array, false otherwise
     */
    public includes(searchElement: long, fromIndex: int): boolean {
        return this.indexOf(searchElement as int, fromIndex) != -1
    }

    /**
     * Determines whether Uint32Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in Uint32Array, false otherwise
     */
    public includes(searchElement: long): boolean {
        return this.indexOf(searchElement as int, 0) != -1
    }

    /**
     * Returns the index of the first occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: number, fromIndex?: number): number {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the first occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: number, fromIndex: int): number {
        if (isNaN(searchElement)) {
            return -1
        }
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) as number == searchElement) {
                return i
            }
        }
        return -1
    }

    /**
     * Returns the index of the first occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int, fromIndex: int): number {
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) == searchElement as long) {
                return i
            }
        }
        return -1

    }

    /**
     * Returns the index of the first occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int): number {
        return this.indexOf(searchElement, 0)
    }

    /**
     * Adds all the elements of an array separated by the specified separator string
     *
     * @param separator A string used to separate one element of an array from the next in the
     * resulting String. If omitted, the array elements are separated with a comma
     *
     * @returns joined representation
     */
    public join(separator?: String): string {
        if (separator == undefined) {
            return this.join(",")
        }
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; i++) {
            res.append(this.getUnsafe(i) as number)
            res.append(separator)
        }
        if (this.lengthInt > 0) {
            res.append(this.getUnsafe(this.lengthInt - 1) as number)
        }
        return res.toString()
    }

    /**
     * Returns an list of keys in Uint32Array
     *
     * @returns iterator over keys
     */
    public keys(): IterableIterator<number> {
        return new Uint32ArrayIteratorKeys(this)
    }

    /**
     * Returns the index of the last occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number, fromIndex: number|undefined): number {
        return this.lastIndexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the last occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

    /**
     * Returns the index of the last occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: number, fromIndex: int): number {
        if (isNaN(searchElement)) {
            return -1
        }
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) as number == searchElement) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int, fromIndex: int): number {
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) == searchElement as long) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in Uint32Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

   /**
    * Creates a new Uint32Array using initializer
    *
    * @param data initializer
    *
    * @returns a new Uint32Array from data
    */
    public of(...data: number[]): Uint32Array {
        throw new Error("Uint32Array.of: not implemented")
    }

    /**
     * Creates a new Uint32Array using reversed data from the current one
     *
     * @returns a new Uint32Array using reversed data from the current one
     */
    public reverse(): Uint32Array {
        for (let i: int = 0; i < this.lengthInt / 2 as int; i++) {
            const tmp = this.getUnsafe(this.lengthInt - 1 - i)
            this.setUnsafe(this.lengthInt - 1 - i, this.getUnsafe(i))
            this.setUnsafe(i, tmp)
        }
        return this
    }

    /**
     * Creates a slice of current Uint32Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint32Array with elements of current Uint32Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin?: number, end?: number): Uint32Array {
        return this.slice(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a slice of current Uint32Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint32Array with elements of current Uint32Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: number): Uint32Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint32Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint32Array with elements of current Uint32Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: int): Uint32Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint32Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint32Array with elements of current Uint32Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: number): Uint32Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current Uint32Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new Uint32Array with elements of current Uint32Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: int): Uint32Array {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        if (this.buffer instanceof ArrayBuffer) {
            let buf = (this.buffer as ArrayBuffer).slice(relStart * Uint32Array.BYTES_PER_ELEMENT as int, relEnd * Uint32Array.BYTES_PER_ELEMENT as int) as ArrayBuffer
            return new Uint32Array(buf)
        } else if (this.buffer instanceof SharedArrayBuffer) {
            let buf = (this.buffer as SharedArrayBuffer).slice(relStart * Uint32Array.BYTES_PER_ELEMENT as int, relEnd * Uint32Array.BYTES_PER_ELEMENT as int) as SharedArrayBuffer
            return new Uint32Array(buf)
        } else {
            throw new Error("unexpected type of buffer")
        }
    }

    /**
     * Creates a slice of current Uint32Array using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new Uint32Array with elements of current Uint32Array[begin, this.lengthInt)
     */
    public slice(begin: number): Uint32Array {
        return this.slice(begin as int)
    }

    /**
     * Creates a slice of current Uint32Array using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new Uint32Array with elements of current Uint32Array[begin, this.lengthInt)
     */
    public slice(begin: int): Uint32Array {
        return this.slice(begin, this.lengthInt)
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     * If omitted, the elements are sorted in ascending order.
     *
     * @returns sorted Uint32Array
     */
    public sort(compareFn?: (a: number, b: number) => number): this {
        let arr: long[] = new long[this.lengthInt]
        for (let i = 0; i < this.lengthInt; ++i) {
            arr[i] = this.getUnsafe(i)
        }
        let cmp = (l: long, r: long): number => {
                return (l - r) as number
            }
        if (compareFn != undefined) {
            cmp = (l: long, r: long): number => {
                return compareFn!(l as number, r as number)
            }
        }
        sort(arr, cmp)
        for (let i = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr[i])
        }
        return this
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted Uint32Array
     */
    public sort(compareFn: (a: number) => number): this {
        let cmp = (a: number, b: number) => { return compareFn(a)}
        this.sort(cmp)
        return this
    }

    /**
     * Sorts in-place
     *
     * @param fn compareFn —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted Uint32Array
     */
    public sort(compareFn: () => number): this {
        let cmp = (a: number, b: number) => { return compareFn()}
        this.sort(cmp)
        return this
    }
    /**
     * Creates a Uint32Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint32Array with the same underlying Buffer
     */
    public subarray(begin?: number, end?: number): Uint32Array {
        return this.subarray(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a Uint32Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint32Array with the same underlying Buffer
     */
    public subarray(begin: number, end: number): Uint32Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint32Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint32Array with the same underlying Buffer
     */
    public subarray(begin: number, end: int): Uint32Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint32Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint32Array with the same underlying Buffer
     */
    public subarray(begin: int, end: number): Uint32Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a Uint32Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new Uint32Array with the same underlying Buffer
     */
    public subarray(begin: int, end: int): Uint32Array {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        return new Uint32Array(this.buffer, relStart * Uint32Array.BYTES_PER_ELEMENT as int, count)
    }

    /**
     * Creates a Uint32Array with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new Uint32Array with the same Buffer
     */
    public subarray(begin: number): Uint32Array {
        return this.subarray(begin as int, this.lengthInt)
    }

    /**
     * Creates a Uint32Array with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new Uint32Array with the same Buffer
     */
    public subarray(begin: int): Uint32Array {
        return this.subarray(begin, this.lengthInt)
    }

    /**
     * Converts Uint32Array to a string with respect to locale
     *
     * @param locales
     *
     * @param options
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object, options: Object): string {
        throw new Error("Uint32Array.toLocaleString: not implemented")
    }

    /**
     * Converts Uint32Array to a string with respect to locale
     *
     * @param locales
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object): string {
        return this.toLocaleString(new Object(), new Object())
    }

    /**
     * Converts Uint32Array to a string with respect to locale
     *
     * @returns string representation
     */
    public toLocaleString(): string {
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; ++i) {
            res.append((this.getUnsafe(i) as Number).toLocaleString())
            res.append(",")
        }
        if (this.lengthInt > 0) {
            res.append((this.getUnsafe(this.lengthInt - 1) as Number).toLocaleString())
        }
        return res.toString()
    }

    /**
     * Creates a reversed copy
     *
     * @returns a reversed copy
     */
    public toReversed(): Uint32Array {
        return new Uint32Array(this).reverse()
    }

    /**
     * Creates a sorted copy
     *
     * @returns a sorted copy
     */
    public toSorted(): Uint32Array {
        return new Uint32Array(this).sort()
    }

    /**
     * Returns a string representation of the Uint32Array
     *
     * @returns a string representation of the Uint32Array
     */
    public override toString(): string {
        return this.join(",")
    }

    /**
     * Returns array values iterator
     *
     * @returns an iterator
     */
    public values(): IterableIterator<Number> {
         return new Uint32ArrayIterator(this)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an Uint32Array with replaced value on index
     */
    public with(index: number, value: number): Uint32Array {
        return this.with(index as int, value as long)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an Uint32Array with replaced value on index
     */
    /* public */ internal with(index: int, value: long): Uint32Array {
        let res = new Uint32Array(this)
        res.setUnsafeClamp(index, value)
        return res
    }

    /// === with element lambda functions ===

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts one argument.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number) => boolean): boolean {
        return this.every((element: number, index: number, array: Uint32Array): boolean => predicate(element))
    }

    /**
     * creates a new Uint32Array from current Uint32Array based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint32Array with elements from current Uint32Array that satisfy condition fn
     */
    public filter(fn: (val: number) => boolean): Uint32Array {
        let newF: (val: number, index: number, array: Uint32Array) => boolean =
            (val: number, index: number, array: Uint32Array): boolean => { return fn(val) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: () => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint32Array): boolean => predicate())
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number) => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint32Array): boolean => predicate(value))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number) => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint32Array): boolean => predicate(value)) as number
    }

    /**
     * Finds the last element in the Uint32Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint32Array) => boolean =
            (val: number, index: number, array: Uint32Array): boolean => { return fn(val) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the Uint32Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint32Array) => boolean =
            (val: number, index: number, array: Uint32Array): boolean => { return fn(val) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in Uint32Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (val: number) => void): void {
        this.forEach((value: number, index: number, array: Uint32Array): void => callbackfn(value))
    }

    /**
     * Creates a new Uint32Array using fn(arr[i]) over all elements of current Uint32Array
     *
     * @param fn a function to apply for each element of current Uint32Array
     *
     * @returns a new Uint32Array where for each element from current Uint32Array fn was applied
     */
    public map(fn: (val: number) => number): Uint32Array {
        let newF: (val: number, index: number) => number =
            (val: number, index: number): number => { return fn(val) }
        return this.map(newF)
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts one argument.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number) => boolean): boolean {
        return this.some((element: number, index: number, array: Uint32Array): boolean => predicate(element))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number, index: number, array: Uint32Array) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(this.getUnsafe(i) as number, i as number, this)) {
                return true
            }
        }
        return false
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: number, index: number) => boolean): boolean {
        return this.some((element: number, index: number, array: Uint32Array): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: () => boolean): boolean {
        return this.some((element: number, index: number, array: Uint32Array): boolean => predicate())
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = 0; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U, currentValue: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: (previousValue: U) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = number>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue = this.$_get(0) as number
        for (let i = 1; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal, currVal, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number, currentValue: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal, currVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: number) => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: () => number): number {
        return this.reduce(
                (prevVal: number, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn())
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U, currentValue: number, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U, currentValue: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: (previuosValue: U) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = number>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue: number = this.$_get(this.lengthInt - 1) as number
        for (let i = this.lengthInt - 2; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, this.getUnsafe(i) as number, i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevValue, currValue, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number, currentValue: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevValue, currValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: number) => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint32Array) =>
                        callbackfn(prevValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: () => number): number {
        return this.reduceRight(
                (prevValue: number, currValue: number, currIndex: number, array: Uint32Array) =>
                        callbackfn())
    }

    /**
     * Creates a new Uint32Array using fn(arr[i]) over all elements of current Uint32Array.
     *
     * @param fn a function to apply for each element of current Uint32Array
     *
     * @returns a new Uint32Array where for each element from current Uint32Array fn was applied
     */
    public map(fn: (val: number, index: number) => number): Uint32Array {
        let resBuf = new ArrayBuffer(this.lengthInt * Uint32Array.BYTES_PER_ELEMENT as int)
        let res = new Uint32Array(resBuf)
        for (let i = 0; i < this.lengthInt; i++) {
            const fnRes = fn(this.getUnsafe(i) as number, i as number)
            res.setUnsafeClamp(i, fnRes as long)
        }
        return res
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number, index: number, array: Uint32Array) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (!predicate(this.getUnsafe(i) as number, i as number, this)) {
                return false
            }
        }
        return true
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: number, index: number) => boolean): boolean {
        return this.every((element: number, index: number, array: Uint32Array): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: () => boolean): boolean {
        return this.every((element: number, index: number, array: Uint32Array): boolean => predicate())
    }

    /**
     * Creates a new Uint32Array from current Uint32Array based on a condition fn.
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint32Array with elements from current Uint32Array that satisfy condition fn
     */
    public filter(fn: (val: number, index: number, array: Uint32Array) => boolean): Uint32Array {
        let markers = new boolean[this.lengthInt]
        let resLen = 0
        for (let i = 0; i < this.lengthInt; i++) {
            markers[i] = fn(this.getUnsafe(i) as number, i as number, this)
            if (markers[i]) {
                ++resLen
            }
        }
        let res = new Uint32Array(resLen)
        for (let i = 0, j = 0; i < this.lengthInt; i++) {
            if (markers[i]) {
                res.setUnsafe(j, this.getUnsafe(i))
                ++j
            }
        }
        return res
    }

    /**
     * creates a new Uint32Array from current Uint32Array based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new Uint32Array with elements from current Uint32Array that satisfy condition fn
     */
    public filter(fn: (val: number, index: number) => boolean): Uint32Array {
        let newF: (val: number, index: number, array: Uint32Array) => boolean =
            (val: number, index: number, array: Uint32Array): boolean => { return fn(val, index) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number, index: number, array: Uint32Array) => boolean): number | undefined {
        for (let i = 0; i < this.lengthInt; i++) {
            let val = this.getUnsafe(i) as number
            if (predicate(val, i as number, this)) {
                return val
            }
        }
        return undefined
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns number | undefined
     */
    public find(predicate: (value: number, index: number) => boolean): number | undefined {
        return this.find((value: number, index: number, obj: Uint32Array): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number, index: number, obj: Uint32Array) => boolean): number {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(this.getUnsafe(i) as number, i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: number, index: number) => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint32Array): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: () => boolean): number {
        return this.findIndex((value: number, index: number, obj: Uint32Array): boolean => predicate())
    }

    /**
     * Finds the last element in the Uint32Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number, index: number, array: Uint32Array) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            let val = this.getUnsafe(i) as number
            if (fn(val, i as number, this)) {
                return val
            }
        }
        throw new Error("Uint32Array.findLast: not implemented if an element was not found")
    }

    /**
     * Finds the last element in the Uint32Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: number, index: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint32Array) => boolean =
            (val: number, index: number, array: Uint32Array): boolean => { return fn(val, index) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the Uint32Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number, index: number, array: Uint32Array) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            if (fn(this.getUnsafe(i) as number, i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Finds an index of the last element in the Uint32Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: number, index: number) => boolean): number {
        let newF: (val: number, index: number, array: Uint32Array) => boolean =
            (val: number, index: number, array: Uint32Array): boolean => { return fn(val, index) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in Uint32Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: number, index: number, array: Uint32Array) => void): void {
        for (let i = 0; i < this.lengthInt; i++) {
            callbackfn(this.getUnsafe(i) as number, i as number, this)
        }
    }

    /**
     * Performs the specified action for each element in Uint32Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: number, index: number) => void): void {
        this.forEach((value: number, index: number, array: Uint32Array): void => callbackfn(value, index))
    }

    /**
     * Performs the specified action for each element in Uint32Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: () => void): void {
        this.forEach((value: number, index: number, array: Uint32Array): void => callbackfn())
    }

    /**
     * Returns the object itself
     *
     * @returns Uint32Array
     */
    public valueOf(): Uint32Array {
        return this
    }

    /** Byte offset within the underlying Buffer */
    public get byteOffset(): number {
        return this.byteOffsetInt
    }

    /** Number of bytes used */
    public get byteLength(): number {
        return this.byteLengthInt
    }

    /** Number of long stored in Uint32Array */
    public get length(): number {
        return this.lengthInt
    }

    /** String \"Uint32Array\" */
    public readonly name = "Uint32Array"

    private static clamp(val: long): long {
        return val
    }

    internal setUnsafeClamp(insertPos: int, val: long): void {
        this.setUnsafe(insertPos, val)
    }

    internal getUnsafe(index: int): long {
        index = index * Uint32Array.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: long = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint32Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + i) as long
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint32Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + i) as long
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint32Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + 3 - i) as long
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint32Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + 3 - i) as long
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
        return res
    }

    internal setUnsafe(index: int, val: long): void {
        index = index * Uint32Array.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: long = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint32Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint32Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < Uint32Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + 3 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < Uint32Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + 3 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
    }
}


class BigUint64ArrayIteratorKeys implements IterableIterator<number> {
    private length: int = 0
    private idx: int = 0

    constructor(parent: BigUint64Array) {
        this.length = parent.length as int
    }

    public override $_iterator(): IterableIterator<Number> {
        return this
    }

    override next(): IteratorResult<number> {
        if (this.idx < 0 || this.idx >= this.length) {
            return new IteratorResult<number>()
        }
        return new IteratorResult<number>(false, this.idx++ as number)
    }
}

class BigUint64ArrayIterator implements IterableIterator<BigInt> {
    private parent: BigUint64Array
    private idx: int = 0

    constructor(parent: BigUint64Array) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<BigInt> {
        return this
    }

    override next(): IteratorResult<BigInt> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<BigInt>()
        }
        return new IteratorResult<BigInt>(false, new BigInt(this.parent.getUnsafe(this.idx++)))
    }
}

class BigUint64ArrayIteratorEntries implements IterableIterator<[Number, BigInt]> {
    private parent: BigUint64Array
    private idx: int = 0

    constructor(parent: BigUint64Array) {
        this.parent = parent
    }

    public override $_iterator(): IterableIterator<[Number, BigInt]> {
        return this
    }

    override next(): IteratorResult<[Number, BigInt]> {
        if (this.idx < 0 || this.idx >= this.parent.lengthInt) {
            return new IteratorResult<[Number, BigInt]>()
        }
        return new IteratorResult<[Number, BigInt]>(
            false,
            [new Number(this.idx), new BigInt(this.parent.getUnsafe(this.idx++))] as [Number, BigInt]
        )
    }
}

/**
 * JS BigUint64Array API-compatible class
 */
export class BigUint64Array implements Iterable<BigInt>, ArrayLike<BigInt> {
    public static readonly BYTES_PER_ELEMENT: number = 8

    /** Underlying Buffer */
    public readonly buffer: ArrayBufferLike

    internal readonly byteOffsetInt: int
    internal readonly byteLengthInt: int
    internal readonly lengthInt: int

    /**
     * Creates an empty BigUint64Array.
     */
    public constructor() {
        this(0 as int)
    }

    /**
     * Creates an BigUint64Array with respect to data accessed via Iterable<Number> interface
     */
    public constructor(elements: Iterable<BigInt>) {
        // NOTE (ikorobkov): dealing with this overload is tricky
        // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
        let arr = Array.from<BigInt>(elements)
        this.byteLengthInt = arr.length as int * BigUint64Array.BYTES_PER_ELEMENT as int
        this.lengthInt = arr.length as int
        this.buffer = new ArrayBuffer(this.byteLengthInt)
        this.byteOffsetInt = 0
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr.$_get(i).getULong())
        }
    }

    /**
     * Creates an BigUint64Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type long in newly created BigUint64Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined, length: Number | undefined) {
        let intByteOffset: int = 0
        if (byteOffset != undefined) {
            intByteOffset = byteOffset.intValue()
            if (intByteOffset < 0) {
                throw new RangeError("Range Error: byteOffset " + intByteOffset + " is outside the bounds of the buffer")
            }
        }
        let intByteLength: int
        if (buf instanceof ArrayBuffer) {
            intByteLength = (buf as ArrayBuffer).getByteLength()
        } else if (buf instanceof SharedArrayBuffer) {
            intByteLength = (buf as SharedArrayBuffer).getByteLength()
        } else {
            throw new Error("unexpected type of ArrayBufferLike")
        }
        intByteLength = intByteLength - intByteOffset
        if (intByteLength < 0) {
            throw new RangeError("Range Error: byteLength " + intByteLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
        }

        if (intByteLength % BigUint64Array.BYTES_PER_ELEMENT as int != 0) {
            throw new RangeError("ArrayBufferLike.byteLength should be multiple of 8 as BigUint64Array.BYTES_PER_ELEMENT")
        }
        if (intByteOffset % BigUint64Array.BYTES_PER_ELEMENT as int != 0) {
            throw new RangeError("byteOffset should be multiple of 8 as BigUint64Array.BYTES_PER_ELEMENT")
        }

        let intLength: int
        if (length != undefined) {
            intLength = length.intValue()
            if (intLength > intByteLength / BigUint64Array.BYTES_PER_ELEMENT as int) {
                throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer with byteOffset " + intByteOffset)
            }
        } else {
            intLength = intByteLength / BigUint64Array.BYTES_PER_ELEMENT as int
        }
        if (intLength < 0) {
            throw new RangeError("Range Error: length " + intLength + " is outside the bounds of the buffer")
        }
        if (intLength < intByteLength / BigUint64Array.BYTES_PER_ELEMENT as int) {
            intByteLength = intLength * BigUint64Array.BYTES_PER_ELEMENT as int
        }
        this.byteLengthInt = intByteLength
        this.byteOffsetInt = intByteOffset
        this.lengthInt = intLength
        this.buffer = buf
    }

    /**
     * Creates an BigUint64Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: Number | undefined) {
        this(buf, byteOffset, undefined)
    }

    /**
     * Creates an BigUint64Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type long in newly created BigUint64Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number, length: number) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an BigUint64Array with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: number) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an BigUint64Array with respect to data, byteOffset and length.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     *
     * @param length size of elements of type long in newly created BigUint64Array
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int, length: int) {
        this(buf, new Number(byteOffset), new Number(length))
    }

    /**
     * Creates an BigUint64Array with respect to buf and byteOffset.
     *
     * @param buf data initializer
     *
     * @param byteOffset byte offset from begin of the buf
     */
    public constructor(buf: ArrayBufferLike, byteOffset: int) {
        this(buf, new Number(byteOffset), undefined)
    }

    /**
     * Creates an BigUint64Array with respect to buf.
     *
     * @param buf data initializer
     */
    public constructor(buf: ArrayLike<Number> | ArrayBufferLike) {
        if (buf instanceof ArrayBuffer) {
            this.byteLengthInt = (buf as ArrayBuffer).getByteLength()
            if (this.byteLengthInt % BigUint64Array.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of long as BigUint64Array.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / BigUint64Array.BYTES_PER_ELEMENT as int
            this.buffer = buf as ArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof SharedArrayBuffer) {
            this.byteLengthInt = (buf as SharedArrayBuffer).getByteLength()
            if (this.byteLengthInt % BigUint64Array.BYTES_PER_ELEMENT as int != 0) {
               throw new RangeError("ArrayBufferLike.byteLength should be multiple of long as BigUint64Array.BYTES_PER_ELEMENT")
            }
            this.lengthInt = this.byteLengthInt / BigUint64Array.BYTES_PER_ELEMENT as int
            this.buffer = buf as SharedArrayBuffer
            this.byteOffsetInt = 0
        } else if (buf instanceof ArrayLike) {
            // NOTE (ikorobkov): dealing with this overload is tricky
            // with banned `instanceof` generic, so it is delegated to array here. Initial idea from Set.sts
            let arr = Array.from<Number>((buf as ArrayLike<Number>))
            this.byteLengthInt = arr.length as int * BigUint64Array.BYTES_PER_ELEMENT as int
            this.lengthInt = arr.length as int
            this.buffer = new ArrayBuffer(this.byteLengthInt)
            this.byteOffsetInt = 0
            for (let i: int = 0; i < this.lengthInt; ++i) {
                this.setUnsafe(i, arr.$_get(i).longValue())
            }
        } else {
            throw new Error("unexpected type of buf")
        }
    }

    /**
     * Creates an BigUint64Array with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: int) {
        if (length < 0) {
            throw new RangeError("Range Error: length " + length + " is outside the bounds of the buffer")
        }
        this.lengthInt = length
        this.byteLengthInt = length * BigUint64Array.BYTES_PER_ELEMENT as int
        this.byteOffsetInt = 0
        this.buffer = new ArrayBuffer(this.byteLengthInt)
    }

    /**
     * Creates an BigUint64Array with respect to length.
     *
     * @param length data initializer
     */
    public constructor(length: number) {
        this(length as int)
    }

    /**
     * Creates a copy of BigUint64Array.
     *
     * @param other data initializer
     */
    public constructor(other: BigUint64Array) {
        if (other.buffer instanceof ArrayBuffer) {
            this.buffer = (other.buffer as ArrayBuffer).slice(0 as int, other.byteLength as int) as ArrayBuffer
        } else if (other.buffer instanceof SharedArrayBuffer) {
            this.buffer = (other.buffer as SharedArrayBuffer).slice(0 as int, other.byteLength as int) as SharedArrayBuffer
        } else {
            throw new Error("unexpected type of buffer")
        }
        this.byteLengthInt = other.byteLength as int
        this.lengthInt = other.length as int
        this.byteOffsetInt = 0
    }

    /**
     * Creates an BigUint64Array from number[]
     */
    public constructor(numbers: number[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, this.zeroIfInfinity(new BigInt(numbers[i]).getULong()))
        }
    }

    /**
     * Creates an BigUint64Array from int[]
     */
    public constructor(numbers: int[]) {
        this(numbers.length)
        for (let i: int = 0; i < this.lengthInt; ++i) {
            this.setUnsafeClamp(i, this.zeroIfInfinity(new BigInt(numbers[i]).getULong()))
        }
    }

    internal zeroIfInfinity(val: BigInt): BigInt {
        if ((val.getULong() == Infinity) || (val.getULong() == -Infinity)) {
            return new BigInt(0)
        }
        return new BigInt(val)
    }

    internal zeroIfInfinity(val: long): long {
        if ((val == Infinity) || (val == -Infinity)) {
            return 0 as long
        }
        return val
    }

    /**
     * Iteratorable interface implementation
     *
     * @returns iterator over all elements
     */
    public override $_iterator(): IterableIterator<BigInt> {
         return this.values()
    }

    /**
     * Returns an instance of primitive type at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: number): BigInt | undefined {
        return this.at(index as int)
    }

    /**
     * Returns an instance of primitive type at passed index if index is correct.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public at(index: int): BigInt | undefined {
        let k: int
        if (index >= 0) {
            k = index
        } else {
            k = this.lengthInt + index
        }
        if (k < 0 || k >= this.lengthInt) {
            return undefined
        }
        return new BigInt(this.getUnsafe(k))
    }

    /**
     * Returns an instance of BigInt at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public override $_get(index: number): BigInt {
        return this.$_get(index as int) as BigInt
    }

    /**
     * Returns an instance of BigInt at passed index.
     *
     * @param index index to look at
     *
     * @returns a primitive at index
     */
    public $_get(i: int): BigInt {
        if (i < 0 || i >= this.lengthInt) {
            throw new RangeError("invalid offset")
        }
        return new BigInt(this.getUnsafe(i))
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: BigInt): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: BigInt): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val)
        this.setUnsafeClamp(index, v.getULong())
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: long): void {
        this.$_set(index as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: long): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val)
        this.setUnsafeClamp(index, v)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: number, val: int): void {
        this.$_set(index as int, val as int)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public $_set(index: int, val: int): void {
        // NOTE (ikorobkov): TS doesn't throw exception. Exception was added to avoid memory's out-of-range access
        if (index < 0 || index >= this.lengthInt) {
            throw new RangeError("invalid index")
        }
        let v = this.zeroIfInfinity(val as long)
        this.setUnsafeClamp(index, v)
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: number, end?: number): BigUint64Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: number, end?: number): BigUint64Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: number, start: int, end?: number): BigUint64Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param target insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end?: number): BigUint64Array {
        return this.copyWithin(target as int, start as int, asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Makes a copy of internal elements to targetPos from startPos to endPos.
     *
     * @param insert insert index to place copied elements
     *
     * @param start start index to begin copy from
     *
     * @param end last index to end copy from, excluded
     *
     * See rules of parameters normalization on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin | MDN}
     */
    public copyWithin(target: int, start: int, end: int): BigUint64Array {
        let toPos = normalizeIndex(target, this.lengthInt)
        let fromPos = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        let count: int = finalPos - fromPos
        if (count > (this.lengthInt - toPos)) {
            count = this.lengthInt - toPos
        }
        let direction: int = 1
        if ((fromPos < toPos) && (toPos < fromPos + count)) {
            fromPos = fromPos + count - 1
            toPos   = toPos   + count - 1
            direction = -1
        }
        while (count > 0) {
            const value = this.getUnsafe(fromPos)
            this.setUnsafe(toPos, value)
            fromPos = fromPos + direction
            toPos = toPos + direction
            --count
        }
        return this
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of BigUint64Array.
     *
     * @param target insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: number): BigUint64Array {
        return this.copyWithin(target as int)
    }

    /**
     * Makes a copy of internal elements to targetPos from begin to end of BigUint64Array.
     *
     * @param insert insert index to place copied elements
     *
     * See rules of parameters normalization:
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin}
     */
    public copyWithin(target: int): BigUint64Array {
        return this.copyWithin(target, 0, this.lengthInt)
    }

    /**
     * Returns an array of key, value pairs for every entry in the BigUint64Array
     *
     * @returns key, value pairs for every entry in the array
     */
    public entries(): IterableIterator<[Number, BigInt]> {
        return new BigUint64ArrayIteratorEntries(this)
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: BigInt, start?: number, end?: number): BigUint64Array {
        value = this.zeroIfInfinity(value)
        this.fill(value.getULong(), asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: BigInt, start: int, end?: number): BigUint64Array {
        value = this.zeroIfInfinity(value)
        this.fill(value.getULong(), start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: BigInt, start: int, end: number): BigUint64Array {
        value = this.zeroIfInfinity(value)
        this.fill(value.getULong(), start as int, end as int)
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: BigInt, start: number, end: int): BigUint64Array {
        value = this.zeroIfInfinity(value)
        this.fill(value.getULong(), start as int, end as int)
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: BigInt, start: int, end: int): BigUint64Array {
        value = this.zeroIfInfinity(value)
        this.fill(value.getULong(), start as int, end as int)
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: long, start?: number, end?: number): BigUint64Array {
        this.fill(value, asIntOrDefault(start, 0 as int), asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: long, start: int, end?: number): BigUint64Array {
        this.fill(value, start as int, asIntOrDefault(end, this.lengthInt))
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: long, start: int, end: number): BigUint64Array {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: long, start: number, end: int): BigUint64Array {
        this.fill(value, start as int, end as int)
        return this
    }

    /**
     * Fills the BigUint64Array with specified value
     *
     * @param value new value
     *
     * @returns modified BigUint64Array
     */
    public fill(value: long, start: int, end: int): BigUint64Array {
        const k = normalizeIndex(start, this.lengthInt)
        const finalPos = normalizeIndex(end, this.lengthInt)
        for (let i: int = k; i < finalPos; ++i) {
            this.setUnsafe(i, value)
        }
        return this
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: BigInt): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: BigInt): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: number, val: long): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Assigns val as element on index.
     *
     * @param val value to set
     *
     * @param index index to change
     */
    public set(insertPos: int, val: long): void {
        this.$_set(insertPos as int, val)
    }

    /**
     * Copies all elements of arr to the current BigUint64Array starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: BigInt[], insertPos1: number): void {
        const insertPos = insertPos1 as int
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: long[]): size of arr is greater than BigUint64Array.length")
        }
        for (let i = 0; i < arr.length; i++) {
            let v = this.zeroIfInfinity(arr[i])
            this.setUnsafeClamp(insertPos as int + i as int, v.getULong())
        }
    }

    /**
     * Copies all elements of arr to the current BigUint64Array starting from insertPos.
     *
     * @param arr array to copy data from
     *
     * @param insertPos start index where data from arr will be inserted
     *
     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set}
     */
    public set(arr: long[], insertPos: int): void {
        if (insertPos < 0 || insertPos + arr.length > this.lengthInt) {
            throw new RangeError("set(insertPos: int, arr: long[]): size of arr is greater than BigUint64Array.length")
        }
        for (let i = 0; i < arr.length; i++) {
            let v = this.zeroIfInfinity(arr[i])
            this.setUnsafeClamp(insertPos + i, v)
        }
    }

    /**
     * Copies all elements of arr to the current BigUint64Array.
     *
     * @param arr array to copy data from
     */
    public set(arr: BigInt[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies all elements of arr to the current BigUint64Array.
     *
     * @param arr array to copy data from
     */
    public set(arr: long[]): void {
        this.set(arr, 0)
    }

    /**
     * Copies elements from an ArrayLike object to the BigUint64Array.
     *
     * @param array An ArrayLike object containing the elements to copy.
     *
     * @param offset Optional. The offset into the target array at which to begin writing values from the source array
     */
    public set(array: ArrayLike<BigInt>, offset: number = 0): void {
        const insertPos = offset as int
        if (insertPos < 0 || insertPos + array.length > this.lengthInt) {
            throw new RangeError("offset is out of bounds")
        }
        for (let i = 0; i < array.length; i++) {
            let v = this.zeroIfInfinity(array[i])
            this.setUnsafeClamp(insertPos as int + i as int, v.getULong())
        }
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new BigUint64Array
     */
    public static of(...items: number[]): BigUint64Array {
        throw new Error("Array.of: not implemented")
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new BigUint64Array
     */
    public static of(...items: int[]): BigUint64Array {
        throw new Error("Array.of: not implemented")
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new BigUint64Array
     */
    public static of(...items: long[]): BigUint64Array {
        throw new Error("Array.of: not implemented")
    }

    /**
     * Returns a new array from a set of elements.
     *
     * @param items a set of elements to include in the new array object.
     *
     * @returns new BigUint64Array
     */
    public static of(): BigUint64Array {
        return new BigUint64Array(0 as int)
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @returns new BigUint64Array
     */
    public static from(arr: ArrayLike<BigInt>): BigUint64Array {
        throw new Error("BigUint64Array.from: not implemented")
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new BigUint64Array
     */
    public static from(arrayLike: Iterable<BigInt>, mapfn?: (v: BigInt, k: number) => BigInt): BigUint64Array {
        throw new Error("BigUint64Array.from: not implemented")
    }

    /**
     * Creates an array from an array-like or iterable object.
     *
     * @param arrayLike An array-like or iterable object to convert to an array.
     *
     * @param mapfn A mapping function to call on every element of the array.
     *
     * @returns new BigUint64Array
     */
    public static from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => BigInt): BigUint64Array {
        throw new Error("BigUint64Array.from: not implemented")
    }

    /**
     * Determines whether BigUint64Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in BigUint64Array, false otherwise
     */
    public includes(searchElement: BigInt, fromIndex?: number): boolean {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0)) != -1
    }

    /**
     * Determines whether BigUint64Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in BigUint64Array, false otherwise
     */
    public includes(searchElement: long, fromIndex: int): boolean {
        return this.indexOf(searchElement as int, fromIndex) != -1
    }

    /**
     * Determines whether BigUint64Array includes a certain element, returning true or false as appropriate
     *
     * @param searchElement The element to search for
     *
     * @param fromIndex The position in this array at which to begin searching for searchElement
     *
     * @returns true if searchElement is in BigUint64Array, false otherwise
     */
    public includes(searchElement: long): boolean {
        return this.indexOf(searchElement as int, 0) != -1
    }

    /**
     * Returns the index of the first occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: BigInt, fromIndex?: number): number {
        return this.indexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the first occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: BigInt, fromIndex: int): number {
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (new BigInt(this.getUnsafe(i)) == searchElement) {
                return i
            }
        }
        return -1
    }

    /**
     * Returns the index of the first occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int, fromIndex: int): number {
        fromIndex = normalizeIndex(fromIndex, this.lengthInt)
        for (let i = fromIndex; i < this.lengthInt; i++) {
            if (this.getUnsafe(i) == searchElement as long) {
                return i
            }
        }
        return -1

    }

    /**
     * Returns the index of the first occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
     *  search starts at index 0.
     *
     * @returns index of element if it presents, -1 otherwise
     */
    public indexOf(searchElement: int): number {
        return this.indexOf(searchElement, 0)
    }

    /**
     * Adds all the elements of an array separated by the specified separator string
     *
     * @param separator A string used to separate one element of an array from the next in the
     * resulting String. If omitted, the array elements are separated with a comma
     *
     * @returns joined representation
     */
    public join(separator?: String): string {
        if (separator == undefined) {
            return this.join(",")
        }
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; i++) {
            res.append(new BigInt(this.getUnsafe(i)))
            res.append(separator)
        }
        if (this.lengthInt > 0) {
            res.append(new BigInt(this.getUnsafe(this.lengthInt - 1)))
        }
        return res.toString()
    }

    /**
     * Returns an list of keys in BigUint64Array
     *
     * @returns iterator over keys
     */
    public keys(): IterableIterator<number> {
        return new BigUint64ArrayIteratorKeys(this)
    }

    /**
     * Returns the index of the last occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: BigInt, fromIndex: number|undefined): number {
        return this.lastIndexOf(searchElement, asIntOrDefault(fromIndex, 0))
    }

    /**
     * Returns the index of the last occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: BigInt): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

    /**
     * Returns the index of the last occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: BigInt, fromIndex: int): number {
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (new BigInt(this.getUnsafe(k)) == searchElement) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int, fromIndex: int): number {
        if (this.lengthInt == 0) {
            return -1
        }
        let k: int = this.lengthInt + fromIndex
        if (fromIndex >= 0) {
            k = (this.lengthInt - 1 < fromIndex) ? this.lengthInt - 1 : fromIndex
        }
        while (k >= 0) {
            if (this.getUnsafe(k) == searchElement as long) {
                return k
            }
            k--
        }
        return -1
    }

    /**
     * Returns the index of the last occurrence of a value in BigUint64Array.
     *
     * @param searchElement The value to locate in the array.
     *
     * @param fromIndex The array index at which to begin the search. If fromIndex is undefined, the
     * search starts at index 0. If fromIndex is ommited, the search begins at index length-1
     *
     * @returns right-most index of searchElement. It must be less or equal than fromIndex. -1 if not found
     */
    public lastIndexOf(searchElement: int): number {
        return this.lastIndexOf(searchElement, this.lengthInt - 1)
    }

   /**
    * Creates a new BigUint64Array using initializer
    *
    * @param data initializer
    *
    * @returns a new BigUint64Array from data
    */
    public of(...data: BigInt[]): BigUint64Array {
        throw new Error("BigUint64Array.of: not implemented")
    }

    /**
     * Creates a new BigUint64Array using reversed data from the current one
     *
     * @returns a new BigUint64Array using reversed data from the current one
     */
    public reverse(): BigUint64Array {
        for (let i: int = 0; i < this.lengthInt / 2 as int; i++) {
            const tmp = this.getUnsafe(this.lengthInt - 1 - i)
            this.setUnsafe(this.lengthInt - 1 - i, this.getUnsafe(i))
            this.setUnsafe(i, tmp)
        }
        return this
    }

    /**
     * Creates a slice of current BigUint64Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new BigUint64Array with elements of current BigUint64Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin?: number, end?: number): BigUint64Array {
        return this.slice(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a slice of current BigUint64Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new BigUint64Array with elements of current BigUint64Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: number): BigUint64Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current BigUint64Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new BigUint64Array with elements of current BigUint64Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: number, end: int): BigUint64Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current BigUint64Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new BigUint64Array with elements of current BigUint64Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: number): BigUint64Array {
        return this.slice(begin as int, end as int)
    }

    /**
     * Creates a slice of current BigUint64Array using range [begin, end)
     *
     * @param begin start index to be taken into slice
     *
     * @param end last index to be taken into slice
     *
     * @returns a new BigUint64Array with elements of current BigUint64Array[begin;end) where end index is excluded
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
     */
    public slice(begin: int, end: int): BigUint64Array {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        if (this.buffer instanceof ArrayBuffer) {
            let buf = (this.buffer as ArrayBuffer).slice(relStart * BigUint64Array.BYTES_PER_ELEMENT as int, relEnd * BigUint64Array.BYTES_PER_ELEMENT as int) as ArrayBuffer
            return new BigUint64Array(buf)
        } else if (this.buffer instanceof SharedArrayBuffer) {
            let buf = (this.buffer as SharedArrayBuffer).slice(relStart * BigUint64Array.BYTES_PER_ELEMENT as int, relEnd * BigUint64Array.BYTES_PER_ELEMENT as int) as SharedArrayBuffer
            return new BigUint64Array(buf)
        } else {
            throw new Error("unexpected type of buffer")
        }
    }

    /**
     * Creates a slice of current BigUint64Array using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new BigUint64Array with elements of current BigUint64Array[begin, this.lengthInt)
     */
    public slice(begin: number): BigUint64Array {
        return this.slice(begin as int)
    }

    /**
     * Creates a slice of current BigUint64Array using range [begin, this.lengthInt).
     *
     * @param begin start index to be taken into slice
     *
     * @returns a new BigUint64Array with elements of current BigUint64Array[begin, this.lengthInt)
     */
    public slice(begin: int): BigUint64Array {
        return this.slice(begin, this.lengthInt)
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     * If omitted, the elements are sorted in ascending order.
     *
     * @returns sorted BigUint64Array
     */
    public sort(compareFn?: (a: BigInt, b: BigInt) => number): this {
        let arr: long[] = new long[this.lengthInt]
        for (let i = 0; i < this.lengthInt; ++i) {
            arr[i] = this.getUnsafe(i)
        }
        let cmp = (l: long, r: long): number => {
                return (l - r) as number
            }
        if (compareFn != undefined) {
            cmp = (l: long, r: long): number => {
                return compareFn!(new BigInt(l), new BigInt(r))
            }
        }
        sort(arr, cmp)
        for (let i = 0; i < this.lengthInt; ++i) {
            this.setUnsafe(i, arr[i])
        }
        return this
    }

    /**
     * Sorts in-place
     *
     * @param compareFn comparator —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted BigUint64Array
     */
    public sort(compareFn: (a: BigInt) => number): this {
        let cmp = (a: BigInt, b: BigInt) => { return compareFn(a)}
        this.sort(cmp)
        return this
    }

    /**
     * Sorts in-place
     *
     * @param fn compareFn —  used to determine the order of the elements.
     * compareFn returns a negative value if first argument is less than second argument,
     * zero if they're equal and a positive value otherwise.
     *
     * @returns sorted BigUint64Array
     */
    public sort(compareFn: () => number): this {
        let cmp = (a: BigInt, b: BigInt) => { return compareFn()}
        this.sort(cmp)
        return this
    }
    /**
     * Creates a BigUint64Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new BigUint64Array with the same underlying Buffer
     */
    public subarray(begin?: number, end?: number): BigUint64Array {
        return this.subarray(asIntOrDefault(begin, 0 as int), asIntOrDefault(end, this.lengthInt))
    }

    /**
     * Creates a BigUint64Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new BigUint64Array with the same underlying Buffer
     */
    public subarray(begin: number, end: number): BigUint64Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a BigUint64Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new BigUint64Array with the same underlying Buffer
     */
    public subarray(begin: number, end: int): BigUint64Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a BigUint64Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new BigUint64Array with the same underlying Buffer
     */
    public subarray(begin: int, end: number): BigUint64Array {
        return this.subarray(begin as int, end as int)
    }

    /**
     * Creates a BigUint64Array with the same underlying Buffer
     *
     * @param begin start index, inclusive
     *
     * @param end last index, exclusive
     *
     * @returns new BigUint64Array with the same underlying Buffer
     */
    public subarray(begin: int, end: int): BigUint64Array {
        const len: int = this.lengthInt
        const relStart = normalizeIndex(begin, len)
        const relEnd = normalizeIndex(end, len)
        let count = relEnd - relStart
        if (count < 0) {
            count = 0
        }
        return new BigUint64Array(this.buffer, relStart * BigUint64Array.BYTES_PER_ELEMENT as int, count)
    }

    /**
     * Creates a BigUint64Array with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new BigUint64Array with the same Buffer
     */
    public subarray(begin: number): BigUint64Array {
        return this.subarray(begin as int, this.lengthInt)
    }

    /**
     * Creates a BigUint64Array with the same Buffer
     *
     * @param begin start index, inclusive
     *
     * @returns new BigUint64Array with the same Buffer
     */
    public subarray(begin: int): BigUint64Array {
        return this.subarray(begin, this.lengthInt)
    }

    /**
     * Converts BigUint64Array to a string with respect to locale
     *
     * @param locales
     *
     * @param options
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object, options: Object): string {
        throw new Error("BigUint64Array.toLocaleString: not implemented")
    }

    /**
     * Converts BigUint64Array to a string with respect to locale
     *
     * @param locales
     *
     * @returns string representation
     */
    public toLocaleString(locales: Object): string {
        return this.toLocaleString(new Object(), new Object())
    }

    /**
     * Converts BigUint64Array to a string with respect to locale
     *
     * @returns string representation
     */
    public toLocaleString(): string {
        let res: StringBuilder = new StringBuilder("")
        for (let i = 0; i < this.lengthInt - 1; ++i) {
            res.append(new BigInt(this.getUnsafe(i)).toLocaleString())
            res.append(",")
        }
        if (this.lengthInt > 0) {
            res.append(new BigInt(this.getUnsafe(this.lengthInt - 1)).toLocaleString())
        }
        return res.toString()
    }

    /**
     * Creates a reversed copy
     *
     * @returns a reversed copy
     */
    public toReversed(): BigUint64Array {
        return new BigUint64Array(this).reverse()
    }

    /**
     * Creates a sorted copy
     *
     * @returns a sorted copy
     */
    public toSorted(): BigUint64Array {
        return new BigUint64Array(this).sort()
    }

    /**
     * Returns a string representation of the BigUint64Array
     *
     * @returns a string representation of the BigUint64Array
     */
    public override toString(): string {
        return this.join(",")
    }

    /**
     * Returns array values iterator
     *
     * @returns an iterator
     */
    public values(): IterableIterator<BigInt> {
         return new BigUint64ArrayIterator(this)
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an BigUint64Array with replaced value on index
     */
    public with(index: number, value: BigInt): BigUint64Array {
        return this.with(index as int, value.getULong())
    }

    /**
     * Creates a copy with replaced value on index
     *
     * @param index
     *
     * @param value
     *
     * @returns an BigUint64Array with replaced value on index
     */
    private with(index: int, value: long): BigUint64Array {
        let res = new BigUint64Array(this)
        res.setUnsafeClamp(index, value)
        return res
    }

    /// === with element lambda functions ===

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts one argument.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: BigInt) => boolean): boolean {
        return this.every((element: BigInt, index: number, array: BigUint64Array): boolean => predicate(element))
    }

    /**
     * creates a new BigUint64Array from current BigUint64Array based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new BigUint64Array with elements from current BigUint64Array that satisfy condition fn
     */
    public filter(fn: (val: BigInt) => boolean): BigUint64Array {
        let newF: (val: BigInt, index: number, array: BigUint64Array) => boolean =
            (val: BigInt, index: number, array: BigUint64Array): boolean => { return fn(val) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns BigInt | undefined
     */
    public find(predicate: () => boolean): BigInt | undefined {
        return this.find((value: BigInt, index: number, obj: BigUint64Array): boolean => predicate())
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns BigInt | undefined
     */
    public find(predicate: (value: BigInt) => boolean): BigInt | undefined {
        return this.find((value: BigInt, index: number, obj: BigUint64Array): boolean => predicate(value))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: BigInt) => boolean): number {
        return this.findIndex((value: BigInt, index: number, obj: BigUint64Array): boolean => predicate(value)) as number
    }

    /**
     * Finds the last element in the BigUint64Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: BigInt) => boolean): BigInt {
        let newF: (val: BigInt, index: number, array: BigUint64Array) => boolean =
            (val: BigInt, index: number, array: BigUint64Array): boolean => { return fn(val) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the BigUint64Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: BigInt) => boolean): number {
        let newF: (val: BigInt, index: number, array: BigUint64Array) => boolean =
            (val: BigInt, index: number, array: BigUint64Array): boolean => { return fn(val) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in BigUint64Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (val: BigInt) => void): void {
        this.forEach((value: BigInt, index: number, array: BigUint64Array): void => callbackfn(value))
    }

    /**
     * Creates a new BigUint64Array using fn(arr[i]) over all elements of current BigUint64Array
     *
     * @param fn a function to apply for each element of current BigUint64Array
     *
     * @returns a new BigUint64Array where for each element from current BigUint64Array fn was applied
     */
    public map(fn: (val: BigInt) => BigInt): BigUint64Array {
        let newF: (val: BigInt, index: number) => BigInt =
            (val: BigInt, index: number): BigInt => { return fn(val) }
        return this.map(newF)
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts one argument.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: BigInt) => boolean): boolean {
        return this.some((element: BigInt, index: number, array: BigUint64Array): boolean => predicate(element))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: BigInt, index: number, array: BigUint64Array) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(new BigInt(this.getUnsafe(i)), i as number, this)) {
                return true
            }
        }
        return false
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: (element: BigInt, index: number) => boolean): boolean {
        return this.some((element: BigInt, index: number, array: BigUint64Array): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for any element of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The some method calls the predicate function for each element in the array
     * until the predicate returns a true or until the end of the array.
     *
     * @returns false unless predicate function returns true for an array element,
     * in which case true is immediately returned.
     */
    public some(predicate: () => boolean): boolean {
        return this.some((element: BigInt, index: number, array: BigUint64Array): boolean => predicate())
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = BigInt>(
                callbackfn: (previousValue: U, currentValue: BigInt, currentIndex: number, array: BigUint64Array) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = 0; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, new BigInt(this.getUnsafe(i)), i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = BigInt>(
                callbackfn: (previousValue: U, currentValue: BigInt, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = BigInt>(
                callbackfn: (previousValue: U, currentValue: BigInt) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = BigInt>(
                callbackfn: (previousValue: U) => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments
     * The reduce method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduce<U = BigInt>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduce(
                (prevVal: U, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: BigInt, currentValue: BigInt, currentIndex: number, array: BigUint64Array) => BigInt): BigInt {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue = new BigInt(this.$_get(0))
        for (let i = 1; i < this.lengthInt; i++) {
            accumulatedValue = callbackfn(accumulatedValue, new BigInt(this.getUnsafe(i)), i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: BigInt, currentValue: BigInt, currentIndex: number) => BigInt): BigInt {
        return this.reduce(
                (prevVal: BigInt, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal, currVal, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: BigInt, currentValue: BigInt) => BigInt): BigInt {
        return this.reduce(
                (prevVal: BigInt, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal, currVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: (previousValue: BigInt) => BigInt): BigInt {
        return this.reduce(
                (prevVal: BigInt, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal))
    }

    /**
     * Calls the specified callback function for all the elements in an array.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduce method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array first element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduce method on an empty array without an initial value creates a TypeError
     */
    public reduce(callbackfn: () => BigInt): BigInt {
        return this.reduce(
                (prevVal: BigInt, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn())
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = BigInt>(
                callbackfn: (previousValue: U, currentValue: BigInt, currentIndex: number, array: BigUint64Array) => U,
                initialValue: U): U {
        let accumulatedValue = initialValue
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, new BigInt(this.getUnsafe(i)), i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = BigInt>(
                callbackfn: (previuosValue: U, currentValue: BigInt, currentIndex: number) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal, currVal, currIndex),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = BigInt>(
                callbackfn: (previuosValue: U, currentValue: BigInt) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal, currVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = BigInt>(
                callbackfn: (previuosValue: U) => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevVal),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     *
     * @param initialValue The parameter which value is used as the initial value to start the accumulation.
     * The first call to the callbackfn function provides this value as an argument.
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     */
    public reduceRight<U = BigInt>(
                callbackfn: () => U,
                initialValue: U): U {
        return this.reduceRight(
                (prevVal: U, currVal: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(),
                initialValue)
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts four arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: BigInt, currentValue: BigInt, currentIndex: number, array: BigUint64Array) => BigInt): BigInt {
        if (this.lengthInt == 0) {
            throw new TypeError("Reduce of empty array with no initial value")
        }

        let accumulatedValue: BigInt = new BigInt(this.$_get(this.lengthInt - 1))
        for (let i = this.lengthInt - 2; i >= 0; i--) {
            accumulatedValue = callbackfn(accumulatedValue, new BigInt(this.getUnsafe(i)), i as number, this)
        }
        return accumulatedValue
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts three arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: BigInt, currentValue: BigInt, currentIndex: number) => BigInt): BigInt {
        return this.reduceRight(
                (prevValue: BigInt, currValue: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevValue, currValue, currIndex))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts two arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: BigInt, currentValue: BigInt) => BigInt): BigInt {
        return this.reduceRight(
                (prevValue: BigInt, currValue: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevValue, currValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts one argument.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: (previousValue: BigInt) => BigInt): BigInt {
        return this.reduceRight(
                (prevValue: BigInt, currValue: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn(prevValue))
    }

    /**
     * Calls the specified callback function for all the elements in an array, in descending order.
     * The return value of the callback function is the accumulated result,
     * and is provided as an argument in the next call to the callback function.
     *
     * @param callbackfn A function that accepts no arguments.
     * The reduceRight method calls the callbackfn function one time for each element in the array.
     * The first call to the callbackfn function provides array last element value as an argument
     *
     * @returns The value that results from running the callback function to completion over the entire typed array.
     * calling reduceRight method on an empty array without an initial value creates a TypeError
     */
    public reduceRight(callbackfn: () => BigInt): BigInt {
        return this.reduceRight(
                (prevValue: BigInt, currValue: BigInt, currIndex: number, array: BigUint64Array) =>
                        callbackfn())
    }

    /**
     * Creates a new BigUint64Array using fn(arr[i]) over all elements of current BigUint64Array.
     *
     * @param fn a function to apply for each element of current BigUint64Array
     *
     * @returns a new BigUint64Array where for each element from current BigUint64Array fn was applied
     */
    public map(fn: (val: BigInt, index: number) => BigInt): BigUint64Array {
        let resBuf = new ArrayBuffer(this.lengthInt * BigUint64Array.BYTES_PER_ELEMENT as int)
        let res = new BigUint64Array(resBuf)
        for (let i = 0; i < this.lengthInt; i++) {
            const fnRes = fn(new BigInt(this.getUnsafe(i)), i as number)
            res.setUnsafeClamp(i, fnRes.getULong())
        }
        return res
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts three arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: BigInt, index: number, array: BigUint64Array) => boolean): boolean {
        for (let i = 0; i < this.lengthInt; i++) {
            if (!predicate(new BigInt(this.getUnsafe(i)), i as number, this)) {
                return false
            }
        }
        return true
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts two arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: (element: BigInt, index: number) => boolean): boolean {
        return this.every((element: BigInt, index: number, array: BigUint64Array): boolean => predicate(element, index))
    }

    /**
     * Determines whether the specified callback function returns true for all elements of an array.
     *
     * @param predicate A function that accepts no arguments.
     * The every method calls the predicate function for each element in the array until the predicate returns a false,
     * or until the end of the array.
     *
     * @returns true unless predicate function returns a false for an array element,
     * in which case false is immediately returned.
     */
    public every(predicate: () => boolean): boolean {
        return this.every((element: BigInt, index: number, array: BigUint64Array): boolean => predicate())
    }

    /**
     * Creates a new BigUint64Array from current BigUint64Array based on a condition fn.
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new BigUint64Array with elements from current BigUint64Array that satisfy condition fn
     */
    public filter(fn: (val: BigInt, index: number, array: BigUint64Array) => boolean): BigUint64Array {
        let markers = new boolean[this.lengthInt]
        let resLen = 0
        for (let i = 0; i < this.lengthInt; i++) {
            markers[i] = fn(new BigInt(this.getUnsafe(i)), i as number, this)
            if (markers[i]) {
                ++resLen
            }
        }
        let res = new BigUint64Array(resLen)
        for (let i = 0, j = 0; i < this.lengthInt; i++) {
            if (markers[i]) {
                res.setUnsafe(j, this.getUnsafe(i))
                ++j
            }
        }
        return res
    }

    /**
     * creates a new BigUint64Array from current BigUint64Array based on a condition fn
     *
     * @param fn the condition to apply for each element
     *
     * @returns a new BigUint64Array with elements from current BigUint64Array that satisfy condition fn
     */
    public filter(fn: (val: BigInt, index: number) => boolean): BigUint64Array {
        let newF: (val: BigInt, index: number, array: BigUint64Array) => boolean =
            (val: BigInt, index: number, array: BigUint64Array): boolean => { return fn(val, index) }
        return this.filter(newF)
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns BigInt | undefined
     */
    public find(predicate: (value: BigInt, index: number, array: BigUint64Array) => boolean): BigInt | undefined {
        for (let i = 0; i < this.lengthInt; i++) {
            let val = new BigInt(this.getUnsafe(i))
            if (predicate(val, i as number, this)) {
                return val
            }
        }
        return undefined
    }

    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined
     *
     * @returns BigInt | undefined
     */
    public find(predicate: (value: BigInt, index: number) => boolean): BigInt | undefined {
        return this.find((value: BigInt, index: number, obj: BigUint64Array): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: BigInt, index: number, obj: BigUint64Array) => boolean): number {
        for (let i = 0; i < this.lengthInt; i++) {
            if (predicate(new BigInt(this.getUnsafe(i)), i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: (value: BigInt, index: number) => boolean): number {
        return this.findIndex((value: BigInt, index: number, obj: BigUint64Array): boolean => predicate(value, index))
    }

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise
     *
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1
     *
     * @returns number
     */
    public findIndex(predicate: () => boolean): number {
        return this.findIndex((value: BigInt, index: number, obj: BigUint64Array): boolean => predicate())
    }

    /**
     * Finds the last element in the BigUint64Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: BigInt, index: number, array: BigUint64Array) => boolean): BigInt {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            let val = new BigInt(this.getUnsafe(i))
            if (fn(val, i as number, this)) {
                return val
            }
        }
        throw new Error("BigUint64Array.findLast: not implemented if an element was not found")
    }

    /**
     * Finds the last element in the BigUint64Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the last element that satisfies fn
     */
    public findLast(fn: (val: BigInt, index: number) => boolean): BigInt {
        let newF: (val: BigInt, index: number, array: BigUint64Array) => boolean =
            (val: BigInt, index: number, array: BigUint64Array): boolean => { return fn(val, index) }
        return this.findLast(newF)
    }

    /**
     * Finds an index of the last element in the BigUint64Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: BigInt, index: number, array: BigUint64Array) => boolean): number {
        for (let i = this.lengthInt - 1; i >= 0; i--) {
            if (fn(new BigInt(this.getUnsafe(i)), i as number, this)) {
                return i as number
            }
        }
        return -1 as number
    }

    /**
     * Finds an index of the last element in the BigUint64Array that satisfies the condition
     *
     * @param fn condition
     *
     * @returns the index of the last element that satisfies fn, -1 otherwise
     */
    public findLastIndex(fn: (val: BigInt, index: number) => boolean): number {
        let newF: (val: BigInt, index: number, array: BigUint64Array) => boolean =
            (val: BigInt, index: number, array: BigUint64Array): boolean => { return fn(val, index) }
        return this.findLastIndex(newF) as number
    }

    /**
     * Performs the specified action for each element in BigUint64Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: BigInt, index: number, array: BigUint64Array) => void): void {
        for (let i = 0; i < this.lengthInt; i++) {
            callbackfn(new BigInt(this.getUnsafe(i)), i as number, this)
        }
    }

    /**
     * Performs the specified action for each element in BigUint64Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: (value: BigInt, index: number) => void): void {
        this.forEach((value: BigInt, index: number, array: BigUint64Array): void => callbackfn(value, index))
    }

    /**
     * Performs the specified action for each element in BigUint64Array
     *
     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
     * callbackfn function one time for each element in the array.
     *
     * @returns None
     */
    public forEach(callbackfn: () => void): void {
        this.forEach((value: BigInt, index: number, array: BigUint64Array): void => callbackfn())
    }

    /**
     * Returns the object itself
     *
     * @returns BigUint64Array
     */
    public valueOf(): BigUint64Array {
        return this
    }

    /** Byte offset within the underlying Buffer */
    public get byteOffset(): number {
        return this.byteOffsetInt
    }

    /** Number of bytes used */
    public get byteLength(): number {
        return this.byteLengthInt
    }

    /** Number of long stored in BigUint64Array */
    public get length(): number {
        return this.lengthInt
    }

    /** String \"BigUint64Array\" */
    public readonly name = "BigUint64Array"

    private static clamp(val: long): long {
        return val
    }

    internal setUnsafeClamp(insertPos: int, val: long): void {
        this.setUnsafe(insertPos, val)
    }

    internal getUnsafe(index: int): long {
        index = index * BigUint64Array.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: long = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < BigUint64Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + i) as long
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < BigUint64Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + i) as long
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < BigUint64Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as ArrayBuffer).at(index + 7 - i) as long
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < BigUint64Array.BYTES_PER_ELEMENT as int; i++) {
                    let el = (this.buffer as SharedArrayBuffer).at(index + 7 - i) as long
                    el &= 0xff
                    res |= el << (8 * i)
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
        return res
    }

    internal setUnsafe(index: int, val: long): void {
        index = index * BigUint64Array.BYTES_PER_ELEMENT as int + this.byteOffsetInt
        let res: long = 0
        if (IS_LITTLE_ENDIAN) {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < BigUint64Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < BigUint64Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        } else {
            if (this.buffer instanceof ArrayBuffer) {
                for (let i = 0; i < BigUint64Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as ArrayBuffer).set(index + 7 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else if (this.buffer instanceof SharedArrayBuffer) {
                for (let i = 0; i < BigUint64Array.BYTES_PER_ELEMENT as int; i++) {
                    (this.buffer as SharedArrayBuffer).set(index + 7 - i, (val & 0xff) as byte)
                    val = val >> 8
                }
            } else {
                throw new Error("unexpected type of ArrayBufferLike")
            }
        }
    }
}