assemblyscript
Version:
A TypeScript-like language for WebAssembly.
1,641 lines (1,293 loc) • 59.9 kB
text/typescript
import { COMPARATOR, SORT } from "./util/sort";
import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from "./util/error";
import { joinIntegerArray, joinFloatArray } from "./util/string";
import { REVERSE, FILL } from "./util/bytes";
import { idof } from "./builtins";
import { ArrayBufferView } from "./arraybuffer";
export class Int8Array extends ArrayBufferView {
[key: number]: i8;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<i8>();
constructor(length: i32) {
super(length, alignof<i8>());
}
get length(): i32 {
return this.byteLength;
}
@operator("[]")
private __get(index: i32): i8 {
if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
return load<i8>(this.dataStart + <usize>index);
}
@unsafe @operator("{}")
private __uget(index: i32): i8 {
return load<i8>(this.dataStart + <usize>index);
}
@operator("[]=")
private __set(index: i32, value: native<i8>): void {
if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
store<i8>(this.dataStart + <usize>index, value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: native<i8>): void {
store<i8>(this.dataStart + <usize>index, value);
}
at(index: i32): i8 {
let len = this.byteLength;
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<i8>(this.dataStart + <usize>index);
}
includes(searchElement: i8, fromIndex: i32 = 0): bool {
return INCLUDES<Int8Array, i8>(this, searchElement, fromIndex);
}
indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {
return INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);
}
fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {
FILL<u8>(this.dataStart, this.length, u8(value), start, end);
return this;
}
sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR<i8>()): Int8Array {
SORT<i8>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {
return SLICE<Int8Array, i8>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {
return SUBARRAY<Int8Array, i8>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {
return COPY_WITHIN<Int8Array, i8>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
initialValue: T,
): T {
return REDUCE<Int8Array, i8, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Int8Array, i8, T>(this, fn, initialValue);
}
map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {
return MAP<Int8Array, i8>(this, fn);
}
filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {
return FILTER<Int8Array, i8>(this, fn);
}
findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {
return FIND_INDEX<Int8Array, i8>(this, fn);
}
findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {
return FIND_LAST_INDEX<Int8Array, i8>(this, fn);
}
some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {
return SOME<Int8Array, i8>(this, fn);
}
every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {
return EVERY<Int8Array, i8>(this, fn);
}
forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {
FOREACH<Int8Array, i8>(this, fn);
}
reverse(): Int8Array {
REVERSE<u8>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<i8>(this.dataStart, this.length, separator);
}
toString(): string {
return this.join();
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {
return WRAP<Int8Array, i8>(buffer, byteOffset, length);
}
}
export class Uint8Array extends ArrayBufferView {
[key: number]: u8;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();
constructor(length: i32) {
super(length, alignof<u8>());
}
get length(): i32 {
return this.byteLength;
}
@operator("[]")
private __get(index: i32): u8 {
if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u8>(this.dataStart + <usize>index);
}
@unsafe @operator("{}")
private __uget(index: i32): u8 {
return load<u8>(this.dataStart + <usize>index);
}
@operator("[]=")
private __set(index: i32, value: native<u8>): void {
if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
store<u8>(this.dataStart + <usize>index, value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: native<u8>): void {
store<u8>(this.dataStart + <usize>index, value);
}
at(index: i32): u8 {
let len = this.byteLength;
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u8>(this.dataStart + <usize>index);
}
includes(searchElement: u8, fromIndex: i32 = 0): bool {
return INCLUDES<Uint8Array, u8>(this, searchElement, fromIndex);
}
indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {
return INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);
}
fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {
FILL<u8>(this.dataStart, this.length, u8(value), start, end);
return this;
}
sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8Array {
SORT<u8>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {
return SLICE<Uint8Array, u8>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {
return SUBARRAY<Uint8Array, u8>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {
return COPY_WITHIN<Uint8Array, u8>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
initialValue: T,
): T {
return REDUCE<Uint8Array, u8, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint8Array, u8, T>(this, fn, initialValue);
}
map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {
return MAP<Uint8Array, u8>(this, fn);
}
filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {
return FILTER<Uint8Array, u8>(this, fn);
}
findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {
return FIND_INDEX<Uint8Array, u8>(this, fn);
}
findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {
return FIND_LAST_INDEX<Uint8Array, u8>(this, fn);
}
some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
return SOME<Uint8Array, u8>(this, fn);
}
every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
return EVERY<Uint8Array, u8>(this, fn);
}
forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {
FOREACH<Uint8Array, u8>(this, fn);
}
reverse(): Uint8Array {
REVERSE<u8>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<u8>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {
return WRAP<Uint8Array, u8>(buffer, byteOffset, length);
}
}
export class Uint8ClampedArray extends ArrayBufferView {
[key: number]: u8;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();
constructor(length: i32) {
super(length, alignof<u8>());
}
get length(): i32 {
return this.byteLength;
}
@operator("[]")
private __get(index: i32): u8 {
if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u8>(this.dataStart + <usize>index);
}
@unsafe @operator("{}")
private __uget(index: i32): u8 {
return load<u8>(this.dataStart + <usize>index);
}
@operator("[]=")
private __set(index: i32, value: native<u8>): void {
if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));
}
@unsafe @operator("{}=")
private __uset(index: i32, value: native<u8>): void {
store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));
}
at(index: i32): u8 {
let len = this.byteLength;
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u8>(this.dataStart + <usize>index);
}
includes(searchElement: u8, fromIndex: i32 = 0): bool {
return INCLUDES<Uint8ClampedArray, u8>(this, searchElement, fromIndex);
}
indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {
return INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);
}
fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {
value = ~(value >> 31) & (((255 - value) >> 31) | value);
FILL<u8>(this.dataStart, this.length, u8(value), start, end);
return this;
}
sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8ClampedArray {
SORT<u8>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {
return SLICE<Uint8ClampedArray, u8>(this, begin, end);
}
subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {
return SUBARRAY<Uint8ClampedArray, u8>(this, start, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {
return COPY_WITHIN<Uint8ClampedArray, u8>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
initialValue: T,
): T {
return REDUCE<Uint8ClampedArray, u8, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, fn, initialValue);
}
map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {
return MAP<Uint8ClampedArray, u8>(this, fn);
}
filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {
return FILTER<Uint8ClampedArray, u8>(this, fn);
}
findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {
return FIND_INDEX<Uint8ClampedArray, u8>(this, fn);
}
findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {
return FIND_LAST_INDEX<Uint8ClampedArray, u8>(this, fn);
}
some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
return SOME<Uint8ClampedArray, u8>(this, fn);
}
every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
return EVERY<Uint8ClampedArray, u8>(this, fn);
}
forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {
FOREACH<Uint8ClampedArray, u8>(this, fn);
}
reverse(): Uint8ClampedArray {
REVERSE<u8>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<u8>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {
return WRAP<Uint8ClampedArray, u8>(buffer, byteOffset, length);
}
}
export class Int16Array extends ArrayBufferView {
[key: number]: i16;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<i16>();
constructor(length: i32) {
super(length, alignof<i16>());
}
get length(): i32 {
return this.byteLength >>> alignof<i16>();
}
@operator("[]")
private __get(index: i32): i16 {
if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);
return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));
}
@unsafe @operator("{}")
private __uget(index: i32): i16 {
return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));
}
@operator("[]=")
private __set(index: i32, value: native<i16>): void {
if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);
store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: native<i16>): void {
store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);
}
at(index: i32): i16 {
let len = this.byteLength >>> alignof<i16>();
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));
}
includes(searchElement: i16, fromIndex: i32 = 0): bool {
return INCLUDES<Int16Array, i16>(this, searchElement, fromIndex);
}
indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {
return INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);
}
fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {
FILL<u16>(this.dataStart, this.length, u16(value), start, end);
return this;
}
sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR<i16>()): Int16Array {
SORT<i16>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {
return SLICE<Int16Array, i16>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {
return SUBARRAY<Int16Array, i16>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {
return COPY_WITHIN<Int16Array, i16>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
initialValue: T,
): T {
return REDUCE<Int16Array, i16, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Int16Array, i16, T>(this, fn, initialValue);
}
map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {
return MAP<Int16Array, i16>(this, fn);
}
filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {
return FILTER<Int16Array, i16>(this, fn);
}
findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {
return FIND_INDEX<Int16Array, i16>(this, fn);
}
findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {
return FIND_LAST_INDEX<Int16Array, i16>(this, fn);
}
some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {
return SOME<Int16Array, i16>(this, fn);
}
every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {
return EVERY<Int16Array, i16>(this, fn);
}
forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {
FOREACH<Int16Array, i16>(this, fn);
}
reverse(): Int16Array {
REVERSE<u16>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<i16>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {
return WRAP<Int16Array, i16>(buffer, byteOffset, length);
}
}
export class Uint16Array extends ArrayBufferView {
[key: number]: u16;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<u16>();
constructor(length: i32) {
super(length, alignof<u16>());
}
get length(): i32 {
return this.byteLength >>> alignof<u16>();
}
@operator("[]")
private __get(index: i32): u16 {
if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));
}
@unsafe @operator("{}")
private __uget(index: i32): u16 {
return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));
}
@operator("[]=")
private __set(index: i32, value: native<u16>): void {
if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);
store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: native<u16>): void {
store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);
}
at(index: i32): u16 {
let len = this.byteLength >>> alignof<u16>();
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));
}
includes(searchElement: u16, fromIndex: i32 = 0): bool {
return INCLUDES<Uint16Array, u16>(this, searchElement, fromIndex);
}
indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {
return INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);
}
fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {
FILL<u16>(this.dataStart, this.length, u16(value), start, end);
return this;
}
sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR<u16>()): Uint16Array {
SORT<u16>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {
return SLICE<Uint16Array, u16>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {
return SUBARRAY<Uint16Array, u16>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {
return COPY_WITHIN<Uint16Array, u16>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
initialValue: T,
): T {
return REDUCE<Uint16Array, u16, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint16Array, u16, T>(this, fn, initialValue);
}
map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {
return MAP<Uint16Array, u16>(this, fn);
}
filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {
return FILTER<Uint16Array, u16>(this, fn);
}
findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {
return FIND_INDEX<Uint16Array, u16>(this, fn);
}
findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {
return FIND_LAST_INDEX<Uint16Array, u16>(this, fn);
}
some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
return SOME<Uint16Array, u16>(this, fn);
}
every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
return EVERY<Uint16Array, u16>(this, fn);
}
forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {
FOREACH<Uint16Array, u16>(this, fn);
}
reverse(): Uint16Array {
REVERSE<u16>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<u16>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {
return WRAP<Uint16Array, u16>(buffer, byteOffset, length);
}
}
export class Int32Array extends ArrayBufferView {
[key: number]: i32;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<i32>();
constructor(length: i32) {
super(length, alignof<i32>());
}
get length(): i32 {
return this.byteLength >>> alignof<i32>();
}
@operator("[]")
private __get(index: i32): i32 {
if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);
return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));
}
@unsafe @operator("{}")
private __uget(index: i32): i32 {
return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));
}
@operator("[]=")
private __set(index: i32, value: i32): void {
if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);
store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: i32): void {
store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);
}
at(index: i32): i32 {
let len = this.byteLength >>> alignof<i32>();
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));
}
includes(searchElement: i32, fromIndex: i32 = 0): bool {
return INCLUDES<Int32Array, i32>(this, searchElement, fromIndex);
}
indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {
return INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);
}
fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {
FILL<u32>(this.dataStart, this.length, u32(value), start, end);
return this;
}
sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR<i32>()): Int32Array {
SORT<i32>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {
return SLICE<Int32Array, i32>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {
return SUBARRAY<Int32Array, i32>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {
return COPY_WITHIN<Int32Array, i32>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
initialValue: T,
): T {
return REDUCE<Int32Array, i32, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Int32Array, i32, T>(this, fn, initialValue);
}
map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {
return MAP<Int32Array, i32>(this, fn);
}
filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {
return FILTER<Int32Array, i32>(this, fn);
}
findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {
return FIND_INDEX<Int32Array, i32>(this, fn);
}
findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {
return FIND_LAST_INDEX<Int32Array, i32>(this, fn);
}
some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {
return SOME<Int32Array, i32>(this, fn);
}
every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {
return EVERY<Int32Array, i32>(this, fn);
}
forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {
FOREACH<Int32Array, i32>(this, fn);
}
reverse(): Int32Array {
REVERSE<u32>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<i32>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {
return WRAP<Int32Array, i32>(buffer, byteOffset, length);
}
}
export class Uint32Array extends ArrayBufferView {
[key: number]: u32;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<u32>();
constructor(length: i32) {
super(length, alignof<u32>());
}
get length(): i32 {
return this.byteLength >>> alignof<u32>();
}
@operator("[]")
private __get(index: i32): u32 {
if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));
}
@unsafe @operator("{}")
private __uget(index: i32): u32 {
return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));
}
@operator("[]=")
private __set(index: i32, value: u32): void {
if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);
store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: u32): void {
store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);
}
at(index: i32): u32 {
let len = this.byteLength >>> alignof<u32>();
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));
}
includes(searchElement: u32, fromIndex: i32 = 0): bool {
return INCLUDES<Uint32Array, u32>(this, searchElement, fromIndex);
}
indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {
return INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);
}
fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {
FILL<u32>(this.dataStart, this.length, value, start, end);
return this;
}
sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR<u32>()): Uint32Array {
SORT<u32>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {
return SLICE<Uint32Array, u32>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {
return SUBARRAY<Uint32Array, u32>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {
return COPY_WITHIN<Uint32Array, u32>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
initialValue: T,
): T {
return REDUCE<Uint32Array, u32, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint32Array, u32, T>(this, fn, initialValue);
}
map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {
return MAP<Uint32Array, u32>(this, fn);
}
filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {
return FILTER<Uint32Array, u32>(this, fn);
}
findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {
return FIND_INDEX<Uint32Array, u32>(this, fn);
}
findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {
return FIND_LAST_INDEX<Uint32Array, u32>(this, fn);
}
some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
return SOME<Uint32Array, u32>(this, fn);
}
every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
return EVERY<Uint32Array, u32>(this, fn);
}
forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {
FOREACH<Uint32Array, u32>(this, fn);
}
reverse(): Uint32Array {
REVERSE<u32>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<u32>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {
return WRAP<Uint32Array, u32>(buffer, byteOffset, length);
}
}
export class Int64Array extends ArrayBufferView {
[key: number]: i64;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<i64>();
constructor(length: i32) {
super(length, alignof<i64>());
}
get length(): i32 {
return this.byteLength >>> alignof<i64>();
}
@operator("[]")
private __get(index: i32): i64 {
if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);
return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));
}
@unsafe @operator("{}")
private __uget(index: i32): i64 {
return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));
}
@operator("[]=")
private __set(index: i32, value: i64): void {
if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);
store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: i64): void {
store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);
}
at(index: i32): i64 {
let len = this.byteLength >>> alignof<i64>();
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));
}
includes(searchElement: i64, fromIndex: i32 = 0): bool {
return INCLUDES<Int64Array, i64>(this, searchElement, fromIndex);
}
indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {
return INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);
}
fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {
FILL<u64>(this.dataStart, this.length, u64(value), start, end);
return this;
}
sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR<i64>()): Int64Array {
SORT<i64>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {
return SLICE<Int64Array, i64>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {
return SUBARRAY<Int64Array, i64>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {
return COPY_WITHIN<Int64Array, i64>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
initialValue: T,
): T {
return REDUCE<Int64Array, i64, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Int64Array, i64, T>(this, fn, initialValue);
}
map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {
return MAP<Int64Array, i64>(this, fn);
}
filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {
return FILTER<Int64Array, i64>(this, fn);
}
findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {
return FIND_INDEX<Int64Array, i64>(this, fn);
}
findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {
return FIND_LAST_INDEX<Int64Array, i64>(this, fn);
}
some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {
return SOME<Int64Array, i64>(this, fn);
}
every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {
return EVERY<Int64Array, i64>(this, fn);
}
forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {
FOREACH<Int64Array, i64>(this, fn);
}
reverse(): Int64Array {
REVERSE<u64>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<i64>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {
return WRAP<Int64Array, i64>(buffer, byteOffset, length);
}
}
export class Uint64Array extends ArrayBufferView {
[key: number]: u64;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<u64>();
constructor(length: i32) {
super(length, alignof<u64>());
}
get length(): i32 {
return this.byteLength >>> alignof<u64>();
}
@operator("[]")
private __get(index: i32): u64 {
if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));
}
@unsafe @operator("{}")
private __uget(index: i32): u64 {
return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));
}
@operator("[]=")
private __set(index: i32, value: u64): void {
if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);
store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: u64): void {
store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);
}
at(index: i32): u64 {
let len = this.byteLength >>> alignof<u64>();
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));
}
includes(searchElement: u64, fromIndex: i32 = 0): bool {
return INCLUDES<Uint64Array, u64>(this, searchElement, fromIndex);
}
indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {
return INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);
}
fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {
FILL<u64>(this.dataStart, this.length, value, start, end);
return this;
}
sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR<u64>()): Uint64Array {
SORT<u64>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {
return SLICE<Uint64Array, u64>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {
return SUBARRAY<Uint64Array, u64>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {
return COPY_WITHIN<Uint64Array, u64>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
initialValue: T,
): T {
return REDUCE<Uint64Array, u64, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint64Array, u64, T>(this, fn, initialValue);
}
map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {
return MAP<Uint64Array, u64>(this, fn);
}
filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {
return FILTER<Uint64Array, u64>(this, fn);
}
findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {
return FIND_INDEX<Uint64Array, u64>(this, fn);
}
findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {
return FIND_LAST_INDEX<Uint64Array, u64>(this, fn);
}
some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
return SOME<Uint64Array, u64>(this, fn);
}
every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
return EVERY<Uint64Array, u64>(this, fn);
}
forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {
FOREACH<Uint64Array, u64>(this, fn);
}
reverse(): Uint64Array {
REVERSE<u64>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinIntegerArray<u64>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {
return WRAP<Uint64Array, u64>(buffer, byteOffset, length);
}
}
export class Float32Array extends ArrayBufferView {
[key: number]: f32;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<f32>();
constructor(length: i32) {
super(length, alignof<f32>());
}
get length(): i32 {
return this.byteLength >>> alignof<f32>();
}
@operator("[]")
private __get(index: i32): f32 {
if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);
return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));
}
@unsafe @operator("{}")
private __uget(index: i32): f32 {
return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));
}
@operator("[]=")
private __set(index: i32, value: f32): void {
if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);
store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: f32): void {
store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);
}
at(index: i32): f32 {
let len = this.byteLength >>> alignof<f32>();
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));
}
includes(searchElement: f32, fromIndex: i32 = 0): bool {
return INCLUDES<Float32Array, f32>(this, searchElement, fromIndex);
}
indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {
return INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);
}
fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {
FILL<f32>(this.dataStart, this.length, value, start, end);
return this;
}
sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR<f32>()): Float32Array {
SORT<f32>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {
return SLICE<Float32Array, f32>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {
return SUBARRAY<Float32Array, f32>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {
return COPY_WITHIN<Float32Array, f32>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
initialValue: T,
): T {
return REDUCE<Float32Array, f32, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Float32Array, f32, T>(this, fn, initialValue);
}
map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {
return MAP<Float32Array, f32>(this, fn);
}
filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {
return FILTER<Float32Array, f32>(this, fn);
}
findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {
return FIND_INDEX<Float32Array, f32>(this, fn);
}
findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {
return FIND_LAST_INDEX<Float32Array, f32>(this, fn);
}
some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {
return SOME<Float32Array, f32>(this, fn);
}
every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {
return EVERY<Float32Array, f32>(this, fn);
}
forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {
FOREACH<Float32Array, f32>(this, fn);
}
reverse(): Float32Array {
REVERSE<f32>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinFloatArray<f32>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {
return WRAP<Float32Array, f32>(buffer, byteOffset, length);
}
}
export class Float64Array extends ArrayBufferView {
[key: number]: f64;
// @ts-ignore: decorator
@lazy
static readonly BYTES_PER_ELEMENT: i32 = sizeof<f64>();
constructor(length: i32) {
super(length, alignof<f64>());
}
get length(): i32 {
return this.byteLength >>> alignof<f64>();
}
@operator("[]")
private __get(index: i32): f64 {
if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);
return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));
}
@unsafe @operator("{}")
private __uget(index: i32): f64 {
return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));
}
@operator("[]=")
private __set(index: i32, value: f64): void {
if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);
store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);
}
@unsafe @operator("{}=")
private __uset(index: i32, value: f64): void {
store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);
}
at(index: i32): f64 {
let len = this.byteLength >>> alignof<f64>();
index += select(0, len, index >= 0);
if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);
return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));
}
includes(searchElement: f64, fromIndex: i32 = 0): bool {
return INCLUDES<Float64Array, f64>(this, searchElement, fromIndex);
}
indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {
return INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);
}
lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {
return LAST_INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);
}
fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {
FILL<f64>(this.dataStart, this.length, value, start, end);
return this;
}
sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR<f64>()): Float64Array {
SORT<f64>(this.dataStart, this.length, comparator);
return this;
}
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {
return SLICE<Float64Array, f64>(this, begin, end);
}
subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {
return SUBARRAY<Float64Array, f64>(this, begin, end);
}
copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {
return COPY_WITHIN<Float64Array, f64>(this, target, start, end);
}
reduce<T extends number>(
fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
initialValue: T,
): T {
return REDUCE<Float64Array, f64, T>(this, fn, initialValue);
}
reduceRight<T extends number>(
fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Float64Array, f64, T>(this, fn, initialValue);
}
map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {
return MAP<Float64Array, f64>(this, fn);
}
filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {
return FILTER<Float64Array, f64>(this, fn);
}
findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {
return FIND_INDEX<Float64Array, f64>(this, fn);
}
findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {
return FIND_LAST_INDEX<Float64Array, f64>(this, fn);
}
some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {
return SOME<Float64Array, f64>(this, fn);
}
every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {
return EVERY<Float64Array, f64>(this, fn);
}
forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {
FOREACH<Float64Array, f64>(this, fn);
}
reverse(): Float64Array {
REVERSE<f64>(this.dataStart, this.length);
return this;
}
join(separator: string = ","): string {
return joinFloatArray<f64>(this.dataStart, this.length, separator);
}
set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {
SET(this, source, offset);
}
toString(): string {
return this.join();
}
static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {
return WRAP<Float64Array, f64>(buffer, byteOffset, length);
}
}
// @ts-ignore: decorator
@inline
function SLICE<TArray extends ArrayBufferView, T extends number>(
array: TArray,
start: i32,
end: i32
): TArray {
let len = array.length;
start = start < 0 ? max(start + len, 0) : min(start, len);
end = end < 0 ? max(end + len, 0) : min(end , len);
len = max(end - start, 0);
let slice = instantiate<TArray>(len);
memory.copy(
slice.dataStart,
array.dataStart + (<usize>start << alignof<T>()),
<usize>len << alignof<T>()
);
return slice;
}
// @ts-ignore: decorator
@inline
function SUBARRAY<TArray extends ArrayBufferView, T extends number>(
array: TArray,
begin: i32,
end: i32
): TArray {
let len = array.length;
begin = begin < 0 ? max(len + begin, 0) : min(begin, len);
end = end < 0 ? max(len + end, 0) : min(end, len);
end = max(end, begin);
let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));
let buf = changetype<usize>(array.buffer);
store<usize>(changetype<usize>(out), buf, offsetof<TArray>("buffer"));
__link(changetype<usize>(out), buf, false);
store<usize>(changetype<usize>(out), array.dataStart + (<usize>begin << alignof<T>()), offsetof<TArray>("dataStart"));
store<u32>(changetype<usize>(out), (end - begin) << alignof<T>(), offsetof<TArray>("byteLength"));
return out;
}
// @ts-ignore: decorator
@inline
function COPY_WITHIN<TArray extends ArrayBufferView, T extends number>(
array: TArray,
target: i32,
start: i32,
end: i32
): TArray {
let len = array.length;
let ptr = array.dataStart;
end = min<i32>(end, len);
let to = target < 0 ? max(len + target, 0) : min(target, len);
let from = start < 0 ? max(len + start, 0) : min(start, len);
let last = end < 0 ? max(len + end, 0) : min(end, len);
let count = min(last - from, len - to);
memory.copy(
ptr + (<usize>to << alignof<T>()),
ptr + (<usize>from << alignof<T>()),
<usize>count << alignof<T>()
);
return array;
}
// @ts-ignore: decorator
@inline
function REDUCE<TArray extends ArrayBufferView, T extends number, TRet extends number>(
array: TArray,
fn: (accumulator: TRet, value: T, index: i32,