@@ -34,6 +34,18 @@ export class Int8Array extends ArrayBufferView {
34
34
store < i8 > ( this . dataStart + < usize > index , value ) ;
35
35
}
36
36
37
+ includes ( searchElement : i8 , fromIndex : i32 = 0 ) : bool {
38
+ return INCLUDES < Int8Array , i8 > ( this , searchElement , fromIndex ) ;
39
+ }
40
+
41
+ indexOf ( searchElement : i8 , fromIndex : i32 = 0 ) : i32 {
42
+ return INDEX_OF < Int8Array , i8 > ( this , searchElement , fromIndex ) ;
43
+ }
44
+
45
+ lastIndexOf ( searchElement : i8 , fromIndex : i32 = this . length ) : i32 {
46
+ return LAST_INDEX_OF < Int8Array , i8 > ( this , searchElement , fromIndex ) ;
47
+ }
48
+
37
49
fill ( value : i32 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Int8Array {
38
50
return FILL < Int8Array , i8 > ( this , value , start , end ) ;
39
51
}
@@ -116,6 +128,18 @@ export class Uint8Array extends ArrayBufferView {
116
128
store < u8 > ( this . dataStart + < usize > index , value ) ;
117
129
}
118
130
131
+ includes ( searchElement : u8 , fromIndex : i32 = 0 ) : bool {
132
+ return INCLUDES < Uint8Array , u8 > ( this , searchElement , fromIndex ) ;
133
+ }
134
+
135
+ indexOf ( searchElement : u8 , fromIndex : i32 = 0 ) : i32 {
136
+ return INDEX_OF < Uint8Array , u8 > ( this , searchElement , fromIndex ) ;
137
+ }
138
+
139
+ lastIndexOf ( searchElement : u8 , fromIndex : i32 = this . length ) : i32 {
140
+ return LAST_INDEX_OF < Uint8Array , u8 > ( this , searchElement , fromIndex ) ;
141
+ }
142
+
119
143
fill ( value : u32 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Uint8Array {
120
144
return FILL < Uint8Array , u8 > ( this , value , start , end ) ;
121
145
}
@@ -198,6 +222,18 @@ export class Uint8ClampedArray extends ArrayBufferView {
198
222
store < u8 > ( this . dataStart + < usize > index , ~ ( < i32 > value >> 31 ) & ( ( ( 255 - value ) >> 31 ) | value ) ) ;
199
223
}
200
224
225
+ includes ( searchElement : u8 , fromIndex : i32 = 0 ) : bool {
226
+ return INCLUDES < Uint8ClampedArray , u8 > ( this , searchElement , fromIndex ) ;
227
+ }
228
+
229
+ indexOf ( searchElement : u8 , fromIndex : i32 = 0 ) : i32 {
230
+ return INDEX_OF < Uint8ClampedArray , u8 > ( this , searchElement , fromIndex ) ;
231
+ }
232
+
233
+ lastIndexOf ( searchElement : u8 , fromIndex : i32 = this . length ) : i32 {
234
+ return LAST_INDEX_OF < Uint8ClampedArray , u8 > ( this , searchElement , fromIndex ) ;
235
+ }
236
+
201
237
fill ( value : u32 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Uint8ClampedArray {
202
238
return FILL < Uint8ClampedArray , u8 > ( this , value , start , end ) ;
203
239
}
@@ -280,6 +316,18 @@ export class Int16Array extends ArrayBufferView {
280
316
store < i16 > ( this . dataStart + ( < usize > index << alignof < i16 > ( ) ) , value ) ;
281
317
}
282
318
319
+ includes ( searchElement : i16 , fromIndex : i32 = 0 ) : bool {
320
+ return INCLUDES < Int16Array , i16 > ( this , searchElement , fromIndex ) ;
321
+ }
322
+
323
+ indexOf ( searchElement : i16 , fromIndex : i32 = 0 ) : i32 {
324
+ return INDEX_OF < Int16Array , i16 > ( this , searchElement , fromIndex ) ;
325
+ }
326
+
327
+ lastIndexOf ( searchElement : i16 , fromIndex : i32 = this . length ) : i32 {
328
+ return LAST_INDEX_OF < Int16Array , i16 > ( this , searchElement , fromIndex ) ;
329
+ }
330
+
283
331
fill ( value : i32 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Int16Array {
284
332
return FILL < Int16Array , i16 > ( this , value , start , end ) ;
285
333
}
@@ -362,6 +410,18 @@ export class Uint16Array extends ArrayBufferView {
362
410
store < u16 > ( this . dataStart + ( < usize > index << alignof < u16 > ( ) ) , value ) ;
363
411
}
364
412
413
+ includes ( searchElement : u16 , fromIndex : i32 = 0 ) : bool {
414
+ return INCLUDES < Uint16Array , u16 > ( this , searchElement , fromIndex ) ;
415
+ }
416
+
417
+ indexOf ( searchElement : u16 , fromIndex : i32 = 0 ) : i32 {
418
+ return INDEX_OF < Uint16Array , u16 > ( this , searchElement , fromIndex ) ;
419
+ }
420
+
421
+ lastIndexOf ( searchElement : u16 , fromIndex : i32 = this . length ) : i32 {
422
+ return LAST_INDEX_OF < Uint16Array , u16 > ( this , searchElement , fromIndex ) ;
423
+ }
424
+
365
425
fill ( value : u32 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Uint16Array {
366
426
return FILL < Uint16Array , u16 > ( this , value , start , end ) ;
367
427
}
@@ -444,6 +504,18 @@ export class Int32Array extends ArrayBufferView {
444
504
store < i32 > ( this . dataStart + ( < usize > index << alignof < i32 > ( ) ) , value ) ;
445
505
}
446
506
507
+ includes ( searchElement : i32 , fromIndex : i32 = 0 ) : bool {
508
+ return INCLUDES < Int32Array , i32 > ( this , searchElement , fromIndex ) ;
509
+ }
510
+
511
+ indexOf ( searchElement : i32 , fromIndex : i32 = 0 ) : i32 {
512
+ return INDEX_OF < Int32Array , i32 > ( this , searchElement , fromIndex ) ;
513
+ }
514
+
515
+ lastIndexOf ( searchElement : i32 , fromIndex : i32 = this . length ) : i32 {
516
+ return LAST_INDEX_OF < Int32Array , i32 > ( this , searchElement , fromIndex ) ;
517
+ }
518
+
447
519
fill ( value : i32 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Int32Array {
448
520
return FILL < Int32Array , i32 > ( this , value , start , end ) ;
449
521
}
@@ -526,6 +598,18 @@ export class Uint32Array extends ArrayBufferView {
526
598
store < u32 > ( this . dataStart + ( < usize > index << alignof < u32 > ( ) ) , value ) ;
527
599
}
528
600
601
+ includes ( searchElement : u32 , fromIndex : i32 = 0 ) : bool {
602
+ return INCLUDES < Uint32Array , u32 > ( this , searchElement , fromIndex ) ;
603
+ }
604
+
605
+ indexOf ( searchElement : u32 , fromIndex : i32 = 0 ) : i32 {
606
+ return INDEX_OF < Uint32Array , u32 > ( this , searchElement , fromIndex ) ;
607
+ }
608
+
609
+ lastIndexOf ( searchElement : u32 , fromIndex : i32 = this . length ) : i32 {
610
+ return LAST_INDEX_OF < Uint32Array , u32 > ( this , searchElement , fromIndex ) ;
611
+ }
612
+
529
613
fill ( value : u32 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Uint32Array {
530
614
return FILL < Uint32Array , u32 > ( this , value , start , end ) ;
531
615
}
@@ -608,6 +692,18 @@ export class Int64Array extends ArrayBufferView {
608
692
store < i64 > ( this . dataStart + ( < usize > index << alignof < i64 > ( ) ) , value ) ;
609
693
}
610
694
695
+ includes ( searchElement : i64 , fromIndex : i32 = 0 ) : bool {
696
+ return INCLUDES < Int64Array , i64 > ( this , searchElement , fromIndex ) ;
697
+ }
698
+
699
+ indexOf ( searchElement : i64 , fromIndex : i32 = 0 ) : i32 {
700
+ return INDEX_OF < Int64Array , i64 > ( this , searchElement , fromIndex ) ;
701
+ }
702
+
703
+ lastIndexOf ( searchElement : i64 , fromIndex : i32 = this . length ) : i32 {
704
+ return LAST_INDEX_OF < Int64Array , i64 > ( this , searchElement , fromIndex ) ;
705
+ }
706
+
611
707
fill ( value : i64 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Int64Array {
612
708
return FILL < Int64Array , i64 > ( this , value , start , end ) ;
613
709
}
@@ -690,6 +786,18 @@ export class Uint64Array extends ArrayBufferView {
690
786
store < u64 > ( this . dataStart + ( < usize > index << alignof < u64 > ( ) ) , value ) ;
691
787
}
692
788
789
+ includes ( searchElement : u64 , fromIndex : i32 = 0 ) : bool {
790
+ return INCLUDES < Uint64Array , u64 > ( this , searchElement , fromIndex ) ;
791
+ }
792
+
793
+ indexOf ( searchElement : u64 , fromIndex : i32 = 0 ) : i32 {
794
+ return INDEX_OF < Uint64Array , u64 > ( this , searchElement , fromIndex ) ;
795
+ }
796
+
797
+ lastIndexOf ( searchElement : u64 , fromIndex : i32 = this . length ) : i32 {
798
+ return LAST_INDEX_OF < Uint64Array , u64 > ( this , searchElement , fromIndex ) ;
799
+ }
800
+
693
801
fill ( value : u64 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Uint64Array {
694
802
return FILL < Uint64Array , u64 > ( this , value , start , end ) ;
695
803
}
@@ -772,6 +880,18 @@ export class Float32Array extends ArrayBufferView {
772
880
store < f32 > ( this . dataStart + ( < usize > index << alignof < f32 > ( ) ) , value ) ;
773
881
}
774
882
883
+ includes ( searchElement : f32 , fromIndex : i32 = 0 ) : bool {
884
+ return INCLUDES < Float32Array , f32 > ( this , searchElement , fromIndex ) ;
885
+ }
886
+
887
+ indexOf ( searchElement : f32 , fromIndex : i32 = 0 ) : i32 {
888
+ return INDEX_OF < Float32Array , f32 > ( this , searchElement , fromIndex ) ;
889
+ }
890
+
891
+ lastIndexOf ( searchElement : f32 , fromIndex : i32 = this . length ) : i32 {
892
+ return LAST_INDEX_OF < Float32Array , f32 > ( this , searchElement , fromIndex ) ;
893
+ }
894
+
775
895
fill ( value : f32 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Float32Array {
776
896
return FILL < Float32Array , f32 > ( this , value , start , end ) ;
777
897
}
@@ -854,6 +974,18 @@ export class Float64Array extends ArrayBufferView {
854
974
store < f64 > ( this . dataStart + ( < usize > index << alignof < f64 > ( ) ) , value ) ;
855
975
}
856
976
977
+ includes ( searchElement : f64 , fromIndex : i32 = 0 ) : bool {
978
+ return INCLUDES < Float64Array , f64 > ( this , searchElement , fromIndex ) ;
979
+ }
980
+
981
+ indexOf ( searchElement : f64 , fromIndex : i32 = 0 ) : i32 {
982
+ return INDEX_OF < Float64Array , f64 > ( this , searchElement , fromIndex ) ;
983
+ }
984
+
985
+ lastIndexOf ( searchElement : f64 , fromIndex : i32 = this . length ) : i32 {
986
+ return LAST_INDEX_OF < Float64Array , f64 > ( this , searchElement , fromIndex ) ;
987
+ }
988
+
857
989
fill ( value : f64 , start : i32 = 0 , end : i32 = i32 . MAX_VALUE ) : Float64Array {
858
990
return FILL < Float64Array , f64 > ( this , value , start , end ) ;
859
991
}
@@ -1027,6 +1159,55 @@ function FIND_INDEX<TArray extends ArrayBufferView, T>(
1027
1159
return - 1 ;
1028
1160
}
1029
1161
1162
+ // @ts -ignore: decorator
1163
+ @inline
1164
+ function INCLUDES < TArray extends ArrayBufferView , T > (
1165
+ array : TArray ,
1166
+ searchElement : T ,
1167
+ fromIndex : i32 ,
1168
+ ) : bool {
1169
+ return INDEX_OF < TArray , T > ( array , searchElement , fromIndex ) >= 0 ;
1170
+ }
1171
+
1172
+ // @ts -ignore: decorator
1173
+ @inline
1174
+ function INDEX_OF < TArray extends ArrayBufferView , T > (
1175
+ array : TArray ,
1176
+ searchElement : T ,
1177
+ fromIndex : i32 ,
1178
+ ) : i32 {
1179
+ var index : isize = fromIndex ;
1180
+ var length : isize = array . length ;
1181
+ if ( length == 0 || index >= length ) return - 1 ;
1182
+ if ( index < 0 ) index = max ( length + index , 0 ) ;
1183
+ var dataStart = array . dataStart ;
1184
+ while ( index < length ) {
1185
+ if ( load < T > ( dataStart + ( index << alignof < T > ( ) ) ) == searchElement ) return < i32 > index ;
1186
+ ++ index ;
1187
+ }
1188
+ return - 1 ;
1189
+ }
1190
+
1191
+ // @ts -ignore: decorator
1192
+ @inline
1193
+ function LAST_INDEX_OF < TArray extends ArrayBufferView , T > (
1194
+ array : TArray ,
1195
+ searchElement : T ,
1196
+ fromIndex : i32 ,
1197
+ ) : i32 {
1198
+ var index : isize = fromIndex ;
1199
+ var length : isize = array . length ;
1200
+ if ( length == 0 ) return - 1 ;
1201
+ if ( index < 0 ) index = length + index ; // no need to clamp
1202
+ else if ( index >= length ) index = length - 1 ;
1203
+ var dataStart = array . dataStart ;
1204
+ while ( index >= 0 ) {
1205
+ if ( load < T > ( dataStart + ( index << alignof < T > ( ) ) ) == searchElement ) return < i32 > index ;
1206
+ -- index ;
1207
+ }
1208
+ return - 1 ;
1209
+ }
1210
+
1030
1211
// @ts -ignore: decorator
1031
1212
@inline
1032
1213
function SOME < TArray extends ArrayBufferView , T > (
@@ -1070,9 +1251,9 @@ function FOREACH<TArray extends ArrayBufferView, T>(
1070
1251
@inline
1071
1252
export function REVERSE < TArray extends ArrayBufferView , T > ( array : TArray ) : TArray {
1072
1253
var dataStart = array . dataStart ;
1073
- for ( let front = 0 , back = array . length - 1 ; front < back ; ++ front , -- back ) {
1074
- let frontPtr = dataStart + ( < usize > front << alignof < T > ( ) ) ;
1075
- let backPtr = dataStart + ( < usize > back << alignof < T > ( ) ) ;
1254
+ for ( let front : usize = 0 , back : usize = array . length - 1 ; front < back ; ++ front , -- back ) {
1255
+ let frontPtr = dataStart + ( front << alignof < T > ( ) ) ;
1256
+ let backPtr = dataStart + ( back << alignof < T > ( ) ) ;
1076
1257
let temp = load < T > ( frontPtr ) ;
1077
1258
store < T > ( frontPtr , load < T > ( backPtr ) ) ;
1078
1259
store < T > ( backPtr , temp ) ;
0 commit comments