firefly-compiler 0.5.35 → 0.5.36

package/output/js/ff/core/Float.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,125 +94,101 @@ 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 Float
 
 
 
 
-export function hypot_(values_) {
-
-        return Math.hypot(...values_);
-    
+export function hypot_(a_, b_, c_ = 0.0, d_ = 0.0) {
+Math.hypot(a_, b_, c_, d_)
 }
 
 export function e_() {
-
-        return Math.E;
-    
+return Math.E
 }
 
 export function ln10_() {
-
-        return Math.LN10;
-    
+return Math.LN10
 }
 
 export function ln2_() {
-
-        return Math.LN2;
-    
+return Math.LN2
 }
 
 export function log10e_() {
-
-        return Math.LOG10E;
-    
+return Math.LOG10E
 }
 
 export function log2e_() {
-
-        return Math.LOG2E;
-    
+return Math.LOG2E
 }
 
 export function pi_() {
-
-        return Math.PI;
-    
+return Math.PI
 }
 
 export function sqrtHalf_() {
-
-        return Math.SQRT1_2;
-    
+return Math["SQRT1_2"]
 }
 
 export function sqrt2_() {
-
-        return Math.SQRT2;
-    
+return Math.SQRT2
 }
 
 export function nan_() {
-
-        return NaN;
-    
+return NaN
 }
 
 export function infinity_() {
-
-        return Infinity;
-    
+return Infinity
 }
 
-export async function hypot_$(values_, $task) {
-throw new Error('Function hypot is missing on this target in async context.');
+export async function hypot_$(a_, b_, c_ = 0.0, d_ = 0.0, $task) {
+Math.hypot(a_, b_, c_, d_)
 }
 
 export async function e_$($task) {
-throw new Error('Function e is missing on this target in async context.');
+return Math.E
 }
 
 export async function ln10_$($task) {
-throw new Error('Function ln10 is missing on this target in async context.');
+return Math.LN10
 }
 
 export async function ln2_$($task) {
-throw new Error('Function ln2 is missing on this target in async context.');
+return Math.LN2
 }
 
 export async function log10e_$($task) {
-throw new Error('Function log10e is missing on this target in async context.');
+return Math.LOG10E
 }
 
 export async function log2e_$($task) {
-throw new Error('Function log2e is missing on this target in async context.');
+return Math.LOG2E
 }
 
 export async function pi_$($task) {
-throw new Error('Function pi is missing on this target in async context.');
+return Math.PI
 }
 
 export async function sqrtHalf_$($task) {
-throw new Error('Function sqrtHalf is missing on this target in async context.');
+return Math["SQRT1_2"]
 }
 
 export async function sqrt2_$($task) {
-throw new Error('Function sqrt2 is missing on this target in async context.');
+return Math.SQRT2
 }
 
 export async function nan_$($task) {
-throw new Error('Function nan is missing on this target in async context.');
+return NaN
 }
 
 export async function infinity_$($task) {
-throw new Error('Function infinity is missing on this target in async context.');
+return Infinity
 }
 
 export function Float_toInt(self_) {
-return Math.trunc(self_) || 0
+return ff_core_JsValue.JsValue_coalesce(Math.trunc(self_), 0, ff_core_JsValue.ff_core_JsValue_IsJsValue$ff_core_Int_Int)
 }
 
 export function Float_round(self_) {
@@ -265,197 +245,148 @@ return (that_ + ((self_ - that_) * ff_core_Float.Float_exp(((-decay_) * factor_)
 }
 
 export function Float_acos(self_) {
-
-            return Math.acos(self_);
-        
+return Math.acos(self_)
 }
 
 export function Float_acosh(self_) {
-
-            return Math.acosh(self_);
-        
+return Math.acosh(self_)
 }
 
 export function Float_asin(self_) {
-
-            return Math.asin(self_);
-        
+return Math.asin(self_)
 }
 
 export function Float_asinh(self_) {
-
-            return Math.asinh(self_);
-        
+return Math.asinh(self_)
 }
 
 export function Float_atan(self_) {
-
-            return Math.atan(self_);
-        
+return Math.atan(self_)
 }
 
 export function Float_atan2(self_, that_) {
-
-            return Math.atan2(self_, that_);
-        
+return Math.atan2(self_, that_)
 }
 
 export function Float_atanh(self_) {
-
-            return Math.atanh(self_);
-        
+return Math.atanh(self_)
 }
 
 export function Float_cbrt(self_) {
-
-            return Math.cbrt(self_);
-        
+return Math.cbrt(self_)
 }
 
 export function Float_cos(self_) {
-
-            return Math.cos(self_);
-        
+return Math.cos(self_)
 }
 
 export function Float_cosh(self_) {
-
-            return Math.cosh(self_);
-        
+return Math.cosh(self_)
 }
 
 export function Float_exp(self_) {
-
-            return Math.exp(self_);
-        
+return Math.exp(self_)
 }
 
 export function Float_expm1(self_) {
-
-            return Math.expm1(self_);
-        
+return Math.expm1(self_)
 }
 
 export function Float_log(self_, that_) {
-
-            return Math.log2(self_) / Math.log2(that_);
-        
+const l_ = Math.log2(self_);
+return (l_ / Math.log2(that_))
 }
 
 export function Float_log10(self_) {
-
-            return Math.log10(self_);
-        
+return Math.log10(self_)
 }
 
 export function Float_log2(self_) {
-
-            return Math.log2(self_);
-        
+return Math.log2(self_)
 }
 
 export function Float_ln(self_) {
-
-            return Math.log(self_);
-        
+return Math.log(self_)
 }
 
 export function Float_ln1p(self_) {
-
-            return Math.log1p(self_);
-        
+return Math.log1p(self_)
 }
 
 export function Float_sin(self_) {
-
-            return Math.sin(self_);
-        
+return Math.sin(self_)
 }
 
 export function Float_sinh(self_) {
-
-            return Math.sinh(self_);
-        
+return Math.sinh(self_)
 }
 
 export function Float_sqrt(self_) {
-
-            return Math.sqrt(self_);
-        
+return Math.sqrt(self_)
 }
 
 export function Float_tan(self_) {
-
-            return Math.tan(self_);
-        
+return Math.tan(self_)
 }
 
 export function Float_tanh(self_) {
-
-            return Math.tanh(self_);
-        
+return Math.tanh(self_)
 }
 
 export function Float_isFinite(self_) {
-
-            return Number.isFinite(self_);
-        
+return Number.isFinite(self_)
 }
 
 export function Float_isNan(self_) {
-
-            return Number.isNaN(self_);
-        
+return Number.isNaN(self_)
 }
 
 export function Float_isSafeInteger(self_) {
-
-            return Number.isSafeInteger(self_);
-        
+return Number.isSafeInteger(self_)
 }
 
 export async function Float_toInt$(self_, $task) {
-throw new Error('Function Float_toInt is missing on this target in async context.');
+return ff_core_JsValue.JsValue_coalesce(Math.trunc(self_), 0, ff_core_JsValue.ff_core_JsValue_IsJsValue$ff_core_Int_Int)
 }
 
 export async function Float_round$(self_, $task) {
-throw new Error('Function Float_round is missing on this target in async context.');
+return Math.round(self_)
 }
 
 export async function Float_floor$(self_, $task) {
-throw new Error('Function Float_floor is missing on this target in async context.');
+return Math.floor(self_)
 }
 
 export async function Float_ceil$(self_, $task) {
-throw new Error('Function Float_ceil is missing on this target in async context.');
+return Math.ceil(self_)
 }
 
 export async function Float_truncate$(self_, $task) {
-throw new Error('Function Float_truncate is missing on this target in async context.');
+return Math.trunc(self_)
 }
 
 export async function Float_sign$(self_, $task) {
-throw new Error('Function Float_sign is missing on this target in async context.');
+return Math.sign(self_)
 }
 
 export async function Float_abs$(self_, $task) {
-throw new Error('Function Float_abs is missing on this target in async context.');
+return Math.abs(self_)
 }
 
 export async function Float_toFixed$(self_, digits_, $task) {
-throw new Error('Function Float_toFixed is missing on this target in async context.');
+return self_.toFixed(digits_)
 }
 
 export async function Float_min$(self_, that_, $task) {
-throw new Error('Function Float_min is missing on this target in async context.');
+return Math.min(self_, that_)
 }
 
 export async function Float_max$(self_, that_, $task) {
-throw new Error('Function Float_max is missing on this target in async context.');
+return Math.max(self_, that_)
 }
 
 export async function Float_clamp$(self_, from_, to_, $task) {
-throw new Error('Function Float_clamp is missing on this target in async context.');
+return Math.min(Math.max(self_, from_), to_)
 }
 
 export async function Float_lerp$(self_, that_, factor_, $task) {
@@ -472,103 +403,104 @@ return (that_ + ((self_ - that_) * ff_core_Float.Float_exp(((-decay_) * factor_)
 }
 
 export async function Float_acos$(self_, $task) {
-throw new Error('Function Float_acos is missing on this target in async context.');
+return Math.acos(self_)
 }
 
 export async function Float_acosh$(self_, $task) {
-throw new Error('Function Float_acosh is missing on this target in async context.');
+return Math.acosh(self_)
 }
 
 export async function Float_asin$(self_, $task) {
-throw new Error('Function Float_asin is missing on this target in async context.');
+return Math.asin(self_)
 }
 
 export async function Float_asinh$(self_, $task) {
-throw new Error('Function Float_asinh is missing on this target in async context.');
+return Math.asinh(self_)
 }
 
 export async function Float_atan$(self_, $task) {
-throw new Error('Function Float_atan is missing on this target in async context.');
+return Math.atan(self_)
 }
 
 export async function Float_atan2$(self_, that_, $task) {
-throw new Error('Function Float_atan2 is missing on this target in async context.');
+return Math.atan2(self_, that_)
 }
 
 export async function Float_atanh$(self_, $task) {
-throw new Error('Function Float_atanh is missing on this target in async context.');
+return Math.atanh(self_)
 }
 
 export async function Float_cbrt$(self_, $task) {
-throw new Error('Function Float_cbrt is missing on this target in async context.');
+return Math.cbrt(self_)
 }
 
 export async function Float_cos$(self_, $task) {
-throw new Error('Function Float_cos is missing on this target in async context.');
+return Math.cos(self_)
 }
 
 export async function Float_cosh$(self_, $task) {
-throw new Error('Function Float_cosh is missing on this target in async context.');
+return Math.cosh(self_)
 }
 
 export async function Float_exp$(self_, $task) {
-throw new Error('Function Float_exp is missing on this target in async context.');
+return Math.exp(self_)
 }
 
 export async function Float_expm1$(self_, $task) {
-throw new Error('Function Float_expm1 is missing on this target in async context.');
+return Math.expm1(self_)
 }
 
 export async function Float_log$(self_, that_, $task) {
-throw new Error('Function Float_log is missing on this target in async context.');
+const l_ = Math.log2(self_);
+return (l_ / Math.log2(that_))
 }
 
 export async function Float_log10$(self_, $task) {
-throw new Error('Function Float_log10 is missing on this target in async context.');
+return Math.log10(self_)
 }
 
 export async function Float_log2$(self_, $task) {
-throw new Error('Function Float_log2 is missing on this target in async context.');
+return Math.log2(self_)
 }
 
 export async function Float_ln$(self_, $task) {
-throw new Error('Function Float_ln is missing on this target in async context.');
+return Math.log(self_)
 }
 
 export async function Float_ln1p$(self_, $task) {
-throw new Error('Function Float_ln1p is missing on this target in async context.');
+return Math.log1p(self_)
 }
 
 export async function Float_sin$(self_, $task) {
-throw new Error('Function Float_sin is missing on this target in async context.');
+return Math.sin(self_)
 }
 
 export async function Float_sinh$(self_, $task) {
-throw new Error('Function Float_sinh is missing on this target in async context.');
+return Math.sinh(self_)
 }
 
 export async function Float_sqrt$(self_, $task) {
-throw new Error('Function Float_sqrt is missing on this target in async context.');
+return Math.sqrt(self_)
 }
 
 export async function Float_tan$(self_, $task) {
-throw new Error('Function Float_tan is missing on this target in async context.');
+return Math.tan(self_)
 }
 
 export async function Float_tanh$(self_, $task) {
-throw new Error('Function Float_tanh is missing on this target in async context.');
+return Math.tanh(self_)
 }
 
 export async function Float_isFinite$(self_, $task) {
-throw new Error('Function Float_isFinite is missing on this target in async context.');
+return Number.isFinite(self_)
 }
 
 export async function Float_isNan$(self_, $task) {
-throw new Error('Function Float_isNan is missing on this target in async context.');
+return Number.isNaN(self_)
 }
 
 export async function Float_isSafeInteger$(self_, $task) {
-throw new Error('Function Float_isSafeInteger is missing on this target in async context.');
+return Number.isSafeInteger(self_)
 }
 
 export const ff_core_Any_HasAnyTag$ff_core_Float_Float = {