firefly-compiler 0.5.35 → 0.5.36

package/output/js/ff/core/Queue.mjs

@@ -0,0 +1,306 @@
+
+
+import * as ff_core_Any from "../../ff/core/Any.mjs"
+
+import * as ff_core_Array from "../../ff/core/Array.mjs"
+
+import * as ff_core_AssetSystem from "../../ff/core/AssetSystem.mjs"
+
+import * as ff_core_Atomic from "../../ff/core/Atomic.mjs"
+
+import * as ff_core_Bool from "../../ff/core/Bool.mjs"
+
+import * as ff_core_BrowserSystem from "../../ff/core/BrowserSystem.mjs"
+
+import * as ff_core_Buffer from "../../ff/core/Buffer.mjs"
+
+import * as ff_core_BuildSystem from "../../ff/core/BuildSystem.mjs"
+
+import * as ff_core_Channel from "../../ff/core/Channel.mjs"
+
+import * as ff_core_Char from "../../ff/core/Char.mjs"
+
+import * as ff_core_Core from "../../ff/core/Core.mjs"
+
+import * as ff_core_Crypto from "../../ff/core/Crypto.mjs"
+
+import * as ff_core_Duration from "../../ff/core/Duration.mjs"
+
+import * as ff_core_Equal from "../../ff/core/Equal.mjs"
+
+import * as ff_core_Error from "../../ff/core/Error.mjs"
+
+import * as ff_core_FileHandle from "../../ff/core/FileHandle.mjs"
+
+import * as ff_core_Float from "../../ff/core/Float.mjs"
+
+import * as ff_core_HttpClient from "../../ff/core/HttpClient.mjs"
+
+import * as ff_core_Instant from "../../ff/core/Instant.mjs"
+
+import * as ff_core_Int from "../../ff/core/Int.mjs"
+
+import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
+
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
+import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
+
+import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
+
+import * as ff_core_Json from "../../ff/core/Json.mjs"
+
+import * as ff_core_List from "../../ff/core/List.mjs"
+
+import * as ff_core_Lock from "../../ff/core/Lock.mjs"
+
+import * as ff_core_Log from "../../ff/core/Log.mjs"
+
+import * as ff_core_Map from "../../ff/core/Map.mjs"
+
+import * as ff_core_NodeSystem from "../../ff/core/NodeSystem.mjs"
+
+import * as ff_core_Nothing from "../../ff/core/Nothing.mjs"
+
+import * as ff_core_Option from "../../ff/core/Option.mjs"
+
+import * as ff_core_Ordering from "../../ff/core/Ordering.mjs"
+
+import * as ff_core_Pair from "../../ff/core/Pair.mjs"
+
+import * as ff_core_Path from "../../ff/core/Path.mjs"
+
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
+import * as ff_core_Random from "../../ff/core/Random.mjs"
+
+import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
+
+import * as ff_core_Set from "../../ff/core/Set.mjs"
+
+import * as ff_core_Show from "../../ff/core/Show.mjs"
+
+import * as ff_core_SourceLocation from "../../ff/core/SourceLocation.mjs"
+
+import * as ff_core_Stream from "../../ff/core/Stream.mjs"
+
+import * as ff_core_String from "../../ff/core/String.mjs"
+
+import * as ff_core_StringMap from "../../ff/core/StringMap.mjs"
+
+import * as ff_core_Task from "../../ff/core/Task.mjs"
+
+import * as ff_core_Try from "../../ff/core/Try.mjs"
+
+import * as ff_core_Unit from "../../ff/core/Unit.mjs"
+
+// type Queue
+export function Queue(items_, nextKey_) {
+return {items_, nextKey_};
+}
+
+// newtype QueueKey
+
+
+
+export function new_() {
+return ff_core_Queue.Queue(ff_core_IntMap.new_(), 0)
+}
+
+export async function new_$($task) {
+return ff_core_Queue.Queue(ff_core_IntMap.new_(), 0)
+}
+
+export function Queue_push(self_, item_) {
+self_.nextKey_ += 1;
+ff_core_IntMap.IntMap_set(self_.items_, self_.nextKey_, item_);
+return self_.nextKey_
+}
+
+export function Queue_pop(self_) {
+if((ff_core_IntMap.IntMap_size(self_.items_) === 0)) {
+return ff_core_Option.None()
+} else {
+const key_ = self_.items_.keys().next().value;
+const value_ = ff_core_IntMap.IntMap_get(self_.items_, key_);
+ff_core_IntMap.IntMap_remove(self_.items_, key_);
+return value_
+}
+}
+
+export function Queue_first(self_) {
+if((ff_core_IntMap.IntMap_size(self_.items_) === 0)) {
+return ff_core_Option.None()
+} else {
+const key_ = self_.items_.keys().next().value;
+const value_ = ff_core_IntMap.IntMap_get(self_.items_, key_);
+return value_
+}
+}
+
+export function Queue_remove(self_, key_) {
+return ff_core_IntMap.IntMap_remove(self_.items_, key_)
+}
+
+export function Queue_has(self_, key_) {
+return ff_core_IntMap.IntMap_has(self_.items_, key_)
+}
+
+export function Queue_clear(self_) {
+ff_core_IntMap.IntMap_clear(self_.items_)
+}
+
+export function Queue_size(self_) {
+return ff_core_IntMap.IntMap_size(self_.items_)
+}
+
+export function Queue_isEmpty(self_) {
+return (ff_core_Queue.Queue_size(self_) === 0)
+}
+
+export function Queue_each(self_, body_) {
+ff_core_IntMap.IntMap_each(self_.items_, ((k_, v_) => {
+body_(k_, v_)
+}))
+}
+
+export function Queue_eachWhile(self_, body_) {
+ff_core_IntMap.IntMap_eachWhile(self_.items_, ((k_, v_) => {
+return body_(k_, v_)
+}))
+}
+
+export function Queue_toArray(self_) {
+const array_ = ff_core_Array.new_();
+ff_core_Queue.Queue_each(self_, ((_, v_) => {
+array_.array.push(v_)
+}));
+return array_
+}
+
+export function Queue_toList(self_) {
+return ff_core_Array.Array_drain(ff_core_Queue.Queue_toArray(self_))
+}
+
+export function Queue_toStream(self_) {
+return ff_core_List.List_toStream(ff_core_Queue.Queue_toList(self_), false)
+}
+
+export function Queue_keys(self_) {
+const array_ = ff_core_Array.new_();
+ff_core_IntMap.IntMap_each(self_.items_, ((k_, _) => {
+array_.array.push(k_)
+}));
+return ff_core_Array.Array_drain(array_)
+}
+
+export function Queue_values(self_) {
+const array_ = ff_core_Array.new_();
+ff_core_IntMap.IntMap_each(self_.items_, ((_, v_) => {
+array_.array.push(v_)
+}));
+return ff_core_Array.Array_drain(array_)
+}
+
+export function Queue_copy(self_) {
+return ff_core_Queue.Queue(ff_core_IntMap.IntMap_copy(self_.items_), self_.nextKey_)
+}
+
+export async function Queue_push$(self_, item_, $task) {
+self_.nextKey_ += 1;
+ff_core_IntMap.IntMap_set(self_.items_, self_.nextKey_, item_);
+return self_.nextKey_
+}
+
+export async function Queue_pop$(self_, $task) {
+if((ff_core_IntMap.IntMap_size(self_.items_) === 0)) {
+return ff_core_Option.None()
+} else {
+const key_ = self_.items_.keys().next().value;
+const value_ = ff_core_IntMap.IntMap_get(self_.items_, key_);
+ff_core_IntMap.IntMap_remove(self_.items_, key_);
+return value_
+}
+}
+
+export async function Queue_first$(self_, $task) {
+if((ff_core_IntMap.IntMap_size(self_.items_) === 0)) {
+return ff_core_Option.None()
+} else {
+const key_ = self_.items_.keys().next().value;
+const value_ = ff_core_IntMap.IntMap_get(self_.items_, key_);
+return value_
+}
+}
+
+export async function Queue_remove$(self_, key_, $task) {
+return ff_core_IntMap.IntMap_remove(self_.items_, key_)
+}
+
+export async function Queue_has$(self_, key_, $task) {
+return ff_core_IntMap.IntMap_has(self_.items_, key_)
+}
+
+export async function Queue_clear$(self_, $task) {
+ff_core_IntMap.IntMap_clear(self_.items_)
+}
+
+export async function Queue_size$(self_, $task) {
+return ff_core_IntMap.IntMap_size(self_.items_)
+}
+
+export async function Queue_isEmpty$(self_, $task) {
+return (ff_core_Queue.Queue_size(self_) === 0)
+}
+
+export async function Queue_each$(self_, body_, $task) {
+(await ff_core_IntMap.IntMap_each$(self_.items_, (async (k_, v_, $task) => {
+(await body_(k_, v_, $task))
+}), $task))
+}
+
+export async function Queue_eachWhile$(self_, body_, $task) {
+(await ff_core_IntMap.IntMap_eachWhile$(self_.items_, (async (k_, v_, $task) => {
+return (await body_(k_, v_, $task))
+}), $task))
+}
+
+export async function Queue_toArray$(self_, $task) {
+const array_ = ff_core_Array.new_();
+ff_core_Queue.Queue_each(self_, ((_, v_) => {
+array_.array.push(v_)
+}));
+return array_
+}
+
+export async function Queue_toList$(self_, $task) {
+return ff_core_Array.Array_drain(ff_core_Queue.Queue_toArray(self_))
+}
+
+export async function Queue_toStream$(self_, $task) {
+return (await ff_core_List.List_toStream$(ff_core_Queue.Queue_toList(self_), false, $task))
+}
+
+export async function Queue_keys$(self_, $task) {
+const array_ = ff_core_Array.new_();
+ff_core_IntMap.IntMap_each(self_.items_, ((k_, _) => {
+array_.array.push(k_)
+}));
+return ff_core_Array.Array_drain(array_)
+}
+
+export async function Queue_values$(self_, $task) {
+const array_ = ff_core_Array.new_();
+ff_core_IntMap.IntMap_each(self_.items_, ((_, v_) => {
+array_.array.push(v_)
+}));
+return ff_core_Array.Array_drain(array_)
+}
+
+export async function Queue_copy$(self_, $task) {
+return ff_core_Queue.Queue(ff_core_IntMap.IntMap_copy(self_.items_), self_.nextKey_)
+}
+
+
+
+

package/output/js/ff/core/Random.mjs

@@ -42,6 +42,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +70,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -90,10 +94,10 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // type Random
-
+export function Random(s0_, s1_, s2_, c_, spareGauss_) {
+return {s0_, s1_, s2_, c_, spareGauss_};
+}
 
 
 
@@ -112,37 +116,36 @@ return ff_core_Random.newFromFloat_(seed_)
 }
 
 export function newFromBuffer_(buffer_) {
-
-        var n = 0xefc8249d;
-        function mash(data) {
-            for(var i = 0; i < data.byteLength; i++) {
-                n += data.getUint8(i);
-                var h = 0.02519603282416938 * n;
-                n = h >>> 0;
-                h -= n;
-                h *= n;
-                n = h >>> 0;
-                h -= n;
-                n += h * 0x100000000; // 2^32
-            }
-            return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
-        }
-        var space = new DataView(new Uint8Array([32]).buffer);
-        var r = {
-            s0: mash(space),
-            s1: mash(space),
-            s2: mash(space),
-            c: 1,
-            spareGauss: NaN
-        };
-        r.s0 -= mash(buffer_);
-        if(r.s0 < 0) r.s0 += 1;
-        r.s1 -= mash(buffer_);
-        if(r.s1 < 0) r.s1 += 1;
-        r.s2 -= mash(buffer_);
-        if(r.s2 < 0) r.s2 += 1;
-        return r;
-    
+let n_ = ff_core_Int.Int_toFloat(0xefc8249d);
+function mash_(data_) {
+for(let for_i = 0, for_e = ff_core_Buffer.Buffer_size(data_); for_i < for_e; for_i++) {
+const i_ = for_i;
+n_ += ff_core_Int.Int_toFloat(ff_core_Buffer.Buffer_grabUint8(data_, i_));
+let h_ = (0.02519603282416938 * n_);
+n_ = (h_ >>> 0);
+h_ -= n_;
+h_ *= n_;
+n_ = (h_ >>> 0);
+h_ -= n_;
+n_ += (h_ * 0x100000000)
+};
+return ((n_ >>> 0) * 2.3283064365386963e-10)
+}
+const space_ = (new DataView((new Uint8Array([32])).buffer));
+const r_ = ff_core_Random.Random(mash_(space_), mash_(space_), mash_(space_), 1.0, ff_core_Float.nan_());
+r_.s0_ -= mash_(buffer_);
+if((r_.s0_ < 0.0)) {
+r_.s0_ += 1.0
+};
+r_.s1_ -= mash_(buffer_);
+if((r_.s1_ < 0.0)) {
+r_.s1_ += 1.0
+};
+r_.s2_ -= mash_(buffer_);
+if((r_.s2_ < 0.0)) {
+r_.s2_ += 1.0
+};
+return r_
 }
 
 export async function newFromInt_$(seed_, $task) {
@@ -160,29 +163,60 @@ return ff_core_Random.newFromFloat_(seed_)
 }
 
 export async function newFromBuffer_$(buffer_, $task) {
-throw new Error('Function newFromBuffer is missing on this target in async context.');
+let n_ = ff_core_Int.Int_toFloat(0xefc8249d);
+function mash_(data_) {
+for(let for_i = 0, for_e = ff_core_Buffer.Buffer_size(data_); for_i < for_e; for_i++) {
+const i_ = for_i;
+n_ += ff_core_Int.Int_toFloat(ff_core_Buffer.Buffer_grabUint8(data_, i_));
+let h_ = (0.02519603282416938 * n_);
+n_ = (h_ >>> 0);
+h_ -= n_;
+h_ *= n_;
+n_ = (h_ >>> 0);
+h_ -= n_;
+n_ += (h_ * 0x100000000)
+};
+return ((n_ >>> 0) * 2.3283064365386963e-10)
+}
+const space_ = (new DataView((new Uint8Array([32])).buffer));
+const r_ = ff_core_Random.Random(mash_(space_), mash_(space_), mash_(space_), 1.0, ff_core_Float.nan_());
+r_.s0_ -= mash_(buffer_);
+if((r_.s0_ < 0.0)) {
+r_.s0_ += 1.0
+};
+r_.s1_ -= mash_(buffer_);
+if((r_.s1_ < 0.0)) {
+r_.s1_ += 1.0
+};
+r_.s2_ -= mash_(buffer_);
+if((r_.s2_ < 0.0)) {
+r_.s2_ += 1.0
+};
+return r_
 }
 
 export function Random_copy(self_) {
-
-            return {...self_};
-        
+{
+const _1 = self_;
+{
+const _c = _1;
+return ff_core_Random.Random(_c.s0_, _c.s1_, _c.s2_, _c.c_, _c.spareGauss_)
+}
+}
 }
 
 export function Random_nextInt(self_, from_, until_) {
-
-            return Random_nextFloat(self_, from_, until_) | 0;
-        
+return (ff_core_Random.Random_nextFloat(self_, ff_core_Int.Int_toFloat(from_), ff_core_Int.Int_toFloat(until_)) | 0)
 }
 
 export function Random_nextFloat(self_, from_, until_) {
-
-            var t = 2091639 * self_.s0 + self_.c * 2.3283064365386963e-10; // 2^-32
-            self_.s0 = self_.s1;
-            self_.s1 = self_.s2;
-            var uniform = self_.s2 = t - (self_.c = t | 0);
-            return from_ + uniform * (until_ - from_);
-        
+const t_ = ((2091639 * self_.s0_) + (self_.c_ * 2.3283064365386963e-10));
+self_.s0_ = self_.s1_;
+self_.s1_ = self_.s2_;
+self_.c_ = (t_ | 0);
+const uniform_ = (t_ - self_.c_);
+self_.s2_ = uniform_;
+return (from_ + (uniform_ * (until_ - from_)))
 }
 
 export function Random_nextBool(self_) {
@@ -197,31 +231,32 @@ ff_core_Buffer.Buffer_setUint8(buffer_, i_, ff_core_Random.Random_nextInt(self_,
 }
 
 export function Random_nextGauss(self_, mean_, standardDeviation_) {
-
-            if(!isNaN(self_.spareGauss)) {
-                const result = self_.spareGauss * standardDeviation_ + mean_;
-                self_.spareGauss = NaN;
-                return result;
-            } else {
-                let u = 0.5, v = 0.5, s = 0.5;
-                do {
-                    u = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
-                    v = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
-                    s = u * u + v * v;
-                } while(s >= 1 || s == 0);
-                s = Math.sqrt(-2.0 * Math.log(s) / s);
-                self_.spareGauss = v * s;
-                return mean_ + standardDeviation_ * u * s;
-            }
-        
+if((!ff_core_Float.Float_isNan(self_.spareGauss_))) {
+const result_ = ((self_.spareGauss_ * standardDeviation_) + mean_);
+self_.spareGauss_ = ff_core_Float.nan_();
+return result_
+} else {
+let u_ = 0.5;
+let v_ = 0.5;
+let s_ = 0.5;
+while(true) {
+u_ = ((ff_core_Random.Random_nextFloat(self_, 0.0, 1.0) * 2) - 1);
+v_ = ((ff_core_Random.Random_nextFloat(self_, 0.0, 1.0) * 2) - 1);
+s_ = ((u_ * u_) + (v_ * v_));
+if(!((s_ >= 1.0) || (s_ === 0.0))) break
+};
+s_ = ff_core_Float.Float_sqrt((((-2.0) * ff_core_Float.Float_ln(s_)) / s_));
+self_.spareGauss_ = (v_ * s_);
+return (mean_ + ((standardDeviation_ * u_) * s_))
+}
 }
 
 export function Random_shuffleArray(self_, array_) {
 for(let for_i = 0, for_e = (array_.array.length - 1); for_i < for_e; for_i++) {
 const i_ = for_i;
 const j_ = (ff_core_Random.Random_nextInt(self_, 0, (array_.array.length - i_)) + i_);
-const value_ = (array_.array[i_] ?? ff_core_Array.internalGrab_(array_, i_));
-ff_core_Array.Array_set(array_, i_, (array_.array[j_] ?? ff_core_Array.internalGrab_(array_, j_)));
+const value_ = (array_.array[i_] ?? ff_core_Array.Array_grab(array_, i_));
+ff_core_Array.Array_set(array_, i_, (array_.array[j_] ?? ff_core_Array.Array_grab(array_, j_)));
 ff_core_Array.Array_set(array_, j_, value_)
 }
 }
@@ -233,7 +268,7 @@ return ff_core_Array.Array_drain(array_)
 }
 
 export function Random_sampleArray(self_, count_, array_, body_) {
-for(let for_i = 0, for_a = ff_core_Random.Random_shuffleList(self_, ff_core_Array.Array_toList(array_, 0, 9007199254740991)), for_l = Math.min(Math.max(count_, 0), for_a.length); for_i < for_l; for_i++) {
+for(let for_a = ff_core_Random.Random_shuffleList(self_, ff_core_Array.Array_toList(array_, 0, 9007199254740991)), for_i = 0, for_l = Math.min(Math.max(count_, 0), for_a.length); for_i < for_l; for_i++) {
 const _w1 = for_a[for_i];
 body_(_w1)
 }
@@ -244,7 +279,7 @@ return ff_core_List.List_takeFirst(ff_core_Random.Random_shuffleList(self_, list
 }
 
 export function Random_grabArray(self_, array_) {
-return (array_.array[ff_core_Random.Random_nextInt(self_, 0, array_.array.length)] ?? ff_core_Array.internalGrab_(array_, ff_core_Random.Random_nextInt(self_, 0, array_.array.length)))
+return ff_core_Array.Array_grab(array_, ff_core_Random.Random_nextInt(self_, 0, array_.array.length))
 }
 
 export function Random_grabList(self_, list_) {
@@ -252,15 +287,27 @@ return ff_core_List.List_grab(list_, ff_core_Random.Random_nextInt(self_, 0, lis
 }
 
 export async function Random_copy$(self_, $task) {
-throw new Error('Function Random_copy is missing on this target in async context.');
+{
+const _1 = self_;
+{
+const _c = _1;
+return ff_core_Random.Random(_c.s0_, _c.s1_, _c.s2_, _c.c_, _c.spareGauss_)
+}
+}
 }
 
 export async function Random_nextInt$(self_, from_, until_, $task) {
-throw new Error('Function Random_nextInt is missing on this target in async context.');
+return (ff_core_Random.Random_nextFloat(self_, ff_core_Int.Int_toFloat(from_), ff_core_Int.Int_toFloat(until_)) | 0)
 }
 
 export async function Random_nextFloat$(self_, from_, until_, $task) {
-throw new Error('Function Random_nextFloat is missing on this target in async context.');
+const t_ = ((2091639 * self_.s0_) + (self_.c_ * 2.3283064365386963e-10));
+self_.s0_ = self_.s1_;
+self_.s1_ = self_.s2_;
+self_.c_ = (t_ | 0);
+const uniform_ = (t_ - self_.c_);
+self_.s2_ = uniform_;
+return (from_ + (uniform_ * (until_ - from_)))
 }
 
 export async function Random_nextBool$(self_, $task) {
@@ -275,15 +322,32 @@ ff_core_Buffer.Buffer_setUint8(buffer_, i_, ff_core_Random.Random_nextInt(self_,
 }
 
 export async function Random_nextGauss$(self_, mean_, standardDeviation_, $task) {
-throw new Error('Function Random_nextGauss is missing on this target in async context.');
+if((!ff_core_Float.Float_isNan(self_.spareGauss_))) {
+const result_ = ((self_.spareGauss_ * standardDeviation_) + mean_);
+self_.spareGauss_ = ff_core_Float.nan_();
+return result_
+} else {
+let u_ = 0.5;
+let v_ = 0.5;
+let s_ = 0.5;
+while(true) {
+u_ = ((ff_core_Random.Random_nextFloat(self_, 0.0, 1.0) * 2) - 1);
+v_ = ((ff_core_Random.Random_nextFloat(self_, 0.0, 1.0) * 2) - 1);
+s_ = ((u_ * u_) + (v_ * v_));
+if(!((s_ >= 1.0) || (s_ === 0.0))) break
+};
+s_ = ff_core_Float.Float_sqrt((((-2.0) * ff_core_Float.Float_ln(s_)) / s_));
+self_.spareGauss_ = (v_ * s_);
+return (mean_ + ((standardDeviation_ * u_) * s_))
+}
 }
 
 export async function Random_shuffleArray$(self_, array_, $task) {
 for(let for_i = 0, for_e = (array_.array.length - 1); for_i < for_e; for_i++) {
 const i_ = for_i;
 const j_ = (ff_core_Random.Random_nextInt(self_, 0, (array_.array.length - i_)) + i_);
-const value_ = (array_.array[i_] ?? ff_core_Array.internalGrab_(array_, i_));
-ff_core_Array.Array_set(array_, i_, (array_.array[j_] ?? ff_core_Array.internalGrab_(array_, j_)));
+const value_ = (array_.array[i_] ?? ff_core_Array.Array_grab(array_, i_));
+ff_core_Array.Array_set(array_, i_, (array_.array[j_] ?? ff_core_Array.Array_grab(array_, j_)));
 ff_core_Array.Array_set(array_, j_, value_)
 }
 }
@@ -295,7 +359,7 @@ return ff_core_Array.Array_drain(array_)
 }
 
 export async function Random_sampleArray$(self_, count_, array_, body_, $task) {
-for(let for_i = 0, for_a = ff_core_Random.Random_shuffleList(self_, ff_core_Array.Array_toList(array_, 0, 9007199254740991)), for_l = Math.min(Math.max(count_, 0), for_a.length); for_i < for_l; for_i++) {
+for(let for_a = ff_core_Random.Random_shuffleList(self_, ff_core_Array.Array_toList(array_, 0, 9007199254740991)), for_i = 0, for_l = Math.min(Math.max(count_, 0), for_a.length); for_i < for_l; for_i++) {
 const _w1 = for_a[for_i];
 (await body_(_w1, $task))
 }
@@ -306,7 +370,7 @@ return ff_core_List.List_takeFirst(ff_core_Random.Random_shuffleList(self_, list
 }
 
 export async function Random_grabArray$(self_, array_, $task) {
-return (array_.array[ff_core_Random.Random_nextInt(self_, 0, array_.array.length)] ?? ff_core_Array.internalGrab_(array_, ff_core_Random.Random_nextInt(self_, 0, array_.array.length)))
+return ff_core_Array.Array_grab(array_, ff_core_Random.Random_nextInt(self_, 0, array_.array.length))
 }
 
 export async function Random_grabList$(self_, list_, $task) {