firefly-compiler 0.5.35 → 0.5.37

package/output/js/ff/core/StringMap.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,33 +94,32 @@ 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 StringMap
 
 
 
 
 export function new_() {
-return new Map()
+return (new Map())
 }
 
 export async function new_$($task) {
-throw new Error('Function new is missing on this target in async context.');
+return (new Map())
 }
 
 export function StringMap_get(self_, key_) {
-return self_.has(key_) ? ff_core_Option.Some(self_.get(key_)) : ff_core_Option.None()
+const result_ = self_.get(key_);
+if(((!ff_core_JsValue.JsValue_isUndefined(result_)) || self_.has(key_))) {
+return ff_core_Option.Some(result_)
+} else return ff_core_Option.None()
 }
 
 export function StringMap_grab(self_, key_) {
-
-            const result = self_.get(key_)
-            if(key_ === void 0 && !self_.has(key_)) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return result
-        
+const result_ = self_.get(key_);
+if((ff_core_JsValue.JsValue_isUndefined(result_) && (!ff_core_StringMap.StringMap_has(self_, key_)))) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Core.GrabException(), ff_core_Core.ff_core_Any_HasAnyTag$ff_core_Core_GrabException)})
+};
+return result_
 }
 
 export function StringMap_set(self_, key_, value_) {
@@ -139,12 +142,30 @@ export function StringMap_size(self_) {
 return self_.size
 }
 
+export function StringMap_isEmpty(self_) {
+return (ff_core_StringMap.StringMap_size(self_) === 0)
+}
+
 export function StringMap_each(self_, body_) {
-self_.forEach((v, k) => body_(k, v))
+if(false) {
+const iterator_ = self_.entries();
+let result_ = iterator_.next();
+while((!result_.done)) {
+const value_ = result_.value;
+body_(value_[0], value_[1]);
+result_ = iterator_.next()
+}
+} else {
+self_.forEach(((v_, k_) => {
+return body_(k_, v_)
+}))
+}
 }
 
 export function StringMap_eachWhile(self_, body_) {
-for(const [k, v] of self_) if(!body_(k, v)) break
+ff_core_JsValue.JsValue_eachWhile(self_, ((value_) => {
+return body_(value_[0], value_[1])
+}))
 }
 
 export function StringMap_toArray(self_) {
@@ -172,7 +193,7 @@ const array_ = ff_core_Array.new_();
 ff_core_StringMap.StringMap_each(self_, ((k_, v_) => {
 array_.array.push(k_)
 }));
-return ff_core_Array.Array_toList(array_, 0, 9007199254740991)
+return ff_core_Array.Array_drain(array_)
 }
 
 export function StringMap_values(self_) {
@@ -180,11 +201,11 @@ const array_ = ff_core_Array.new_();
 ff_core_StringMap.StringMap_each(self_, ((k_, v_) => {
 array_.array.push(v_)
 }));
-return ff_core_Array.Array_toList(array_, 0, 9007199254740991)
+return ff_core_Array.Array_drain(array_)
 }
 
 export function StringMap_copy(self_) {
-return new Map(self_)
+return (new Map(self_))
 }
 
 export function StringMap_getOrSet(self_, key_, body_) {
@@ -195,39 +216,64 @@ return ff_core_StringMap.StringMap_grab(self_, key_)
 }
 
 export async function StringMap_get$(self_, key_, $task) {
-throw new Error('Function StringMap_get is missing on this target in async context.');
+const result_ = self_.get(key_);
+if(((!ff_core_JsValue.JsValue_isUndefined(result_)) || self_.has(key_))) {
+return ff_core_Option.Some(result_)
+} else return ff_core_Option.None()
 }
 
 export async function StringMap_grab$(self_, key_, $task) {
-throw new Error('Function StringMap_grab is missing on this target in async context.');
+const result_ = self_.get(key_);
+if((ff_core_JsValue.JsValue_isUndefined(result_) && (!ff_core_StringMap.StringMap_has(self_, key_)))) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Core.GrabException(), ff_core_Core.ff_core_Any_HasAnyTag$ff_core_Core_GrabException)})
+};
+return result_
 }
 
 export async function StringMap_set$(self_, key_, value_, $task) {
-throw new Error('Function StringMap_set is missing on this target in async context.');
+self_.set(key_, value_)
 }
 
 export async function StringMap_has$(self_, key_, $task) {
-throw new Error('Function StringMap_has is missing on this target in async context.');
+return self_.has(key_)
 }
 
 export async function StringMap_remove$(self_, key_, $task) {
-throw new Error('Function StringMap_remove is missing on this target in async context.');
+return self_.delete(key_)
 }
 
 export async function StringMap_clear$(self_, $task) {
-throw new Error('Function StringMap_clear is missing on this target in async context.');
+self_.clear()
 }
 
 export async function StringMap_size$(self_, $task) {
-throw new Error('Function StringMap_size is missing on this target in async context.');
+return self_.size
+}
+
+export async function StringMap_isEmpty$(self_, $task) {
+return (ff_core_StringMap.StringMap_size(self_) === 0)
 }
 
 export async function StringMap_each$(self_, body_, $task) {
-for(const [k, v] of self_) await body_(k, v)
+if(true) {
+const iterator_ = self_.entries();
+let result_ = iterator_.next();
+while((!result_.done)) {
+const value_ = result_.value;
+(await body_(value_[0], value_[1], $task));
+result_ = iterator_.next()
+}
+} else {
+self_.forEach((async (a_1, a_2) => await (async (v_, k_, $task) => {
+return (await body_(k_, v_, $task))
+})(a_1, a_2, $task)))
+}
 }
 
 export async function StringMap_eachWhile$(self_, body_, $task) {
-for(const [k, v] of self_) if(!await body_(k, v)) break
+(await ff_core_JsValue.JsValue_eachWhile$(self_, (async (value_, $task) => {
+return (await body_(value_[0], value_[1], $task))
+}), $task))
 }
 
 export async function StringMap_toArray$(self_, $task) {
@@ -255,7 +301,7 @@ const array_ = ff_core_Array.new_();
 ff_core_StringMap.StringMap_each(self_, ((k_, v_) => {
 array_.array.push(k_)
 }));
-return ff_core_Array.Array_toList(array_, 0, 9007199254740991)
+return ff_core_Array.Array_drain(array_)
 }
 
 export async function StringMap_values$(self_, $task) {
@@ -263,11 +309,11 @@ const array_ = ff_core_Array.new_();
 ff_core_StringMap.StringMap_each(self_, ((k_, v_) => {
 array_.array.push(v_)
 }));
-return ff_core_Array.Array_toList(array_, 0, 9007199254740991)
+return ff_core_Array.Array_drain(array_)
 }
 
 export async function StringMap_copy$(self_, $task) {
-throw new Error('Function StringMap_copy is missing on this target in async context.');
+return (new Map(self_))
 }
 
 export async function StringMap_getOrSet$(self_, key_, body_, $task) {
@@ -284,7 +330,7 @@ if(_1.None) {
 ff_core_StringMap.StringMap_set(self_, key_, ff_core_List.List_toArray([value_]))
 return
 }
-if(_1.Some) {
+{
 const array_ = _1.value_;
 array_.array.push(value_)
 return
@@ -299,7 +345,7 @@ if(_1.None) {
 ff_core_StringMap.StringMap_set(self_, key_, ff_core_List.List_toArray([value_]))
 return
 }
-if(_1.Some) {
+{
 const array_ = _1.value_;
 array_.array.push(value_)
 return

package/output/js/ff/core/Task.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 Task
-
+export function Task(controller_, subtasks_, promise_, started_) {
+return {controller_, subtasks_, promise_, started_};
+}
 
 
 
@@ -102,56 +106,55 @@ import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
 
 
 export function Task_spawn(self_, body_) {
-
-            ff_core_Task.Task_throwIfAborted(self_)
-            const task = {controller: new AbortController(), subtasks: new Set(), started: performance.now() * 0.001}
-            self_.subtasks.add(task)
-            task.promise = Promise.resolve(task).then(async () => {
-                try {
-                    await body_(task, task)
-                } catch(e) {
-                    await ff_core_Task.Task_abort$(self_)
-                    throw e
-                } finally {
-                    for(const subtask of task.subtasks) subtask.controller.abort()
-                    await Promise.allSettled([...task.subtasks].map(subtask => subtask.promise))
-                    self_.subtasks.delete(task)
-                }
-            })
-            return task
-        
+ff_core_Task.Task_throwIfAborted(self_);
+const task_ = ff_core_Task.Task((new AbortController()), (new Set()), (void 0), (performance.now() * 0.001));
+self_.subtasks_.add(task_);
+task_.promise_ = Promise.resolve(task_).then(async () => {
+return ff_core_Try.Try_finally(ff_core_Try.Try_tryCatchAny(ff_core_Core.try_((() => {
+return body_(task_, task_)
+})), ((e_) => {
+self_.controller_.abort();
+return ff_core_Error.Error_rethrow(e_)
+})), (() => {
+ff_core_JsValue.JsValue_each(task_.subtasks_, ((subtask_) => {
+subtask_.controller_.abort()
+}));
+Promise.allSettled(ff_core_List.List_map([...task_.subtasks_], ((subtask_) => {
+return subtask_.promise_
+})));
+self_.subtasks_.delete(task_)
+}))
+});
+return task_
 }
 
 export function Task_throwIfAborted(self_) {
-
-            if(self_.controller.signal.aborted) {
-                const signal = self_.controller.signal
-                self_.controller = new AbortController()
-                signal.throwIfAborted()
-            }
-        
+const signal_ = self_.controller_.signal;
+if(signal_.aborted) {
+self_.controller_ = (new AbortController());
+signal_.throwIfAborted()
+}
 }
 
 export function Task_abort(self_) {
-
-            self_.controller.abort()
-        
+self_.controller_.abort()
 }
 
 export function Task_channel(self_, capacity_ = 0) {
-return {capacity: capacity_, buffer: [], readers: new Set(), writers: new Set()}
+return ff_core_Channel.Channel(capacity_, ff_core_Array.new_(), (new Set()), (new Set()))
 }
 
 export function Task_lock(self_) {
-throw new Error('Function Task_lock is missing on this target in sync context.');
+return ff_core_Lock.Lock((void 0), 0, ff_core_Queue.new_())
 }
 
 export function Task_now(self_) {
-return Date.now() * 0.001
+return (Date.now() * 0.001)
 }
 
 export function Task_elapsed(self_) {
-return performance.now() * 0.001 - self_.started
+const now_ = (performance.now() * 0.001);
+return (now_ - self_.started_)
 }
 
 export function Task_time(self_, body_) {
@@ -163,37 +166,55 @@ return ff_core_Pair.Pair(result_, duration_)
 }
 
 export async function Task_spawn$(self_, body_, $task) {
-
-            return ff_core_Task.Task_spawn(self_, body_)
-        
+(await ff_core_Task.Task_throwIfAborted$(self_, $task));
+const task_ = ff_core_Task.Task((new AbortController()), (new Set()), (void 0), (performance.now() * 0.001));
+self_.subtasks_.add(task_);
+task_.promise_ = Promise.resolve(task_).then(async () => {
+return ff_core_Try.Try_finally(ff_core_Try.Try_tryCatchAny(ff_core_Core.try_((async ($task) => {
+return (await body_(task_, task_))
+})), (async (e_, $task) => {
+(await self_.controller_.abort());
+return ff_core_Error.Error_rethrow(e_)
+})), (async ($task) => {
+ff_core_JsValue.JsValue_each(task_.subtasks_, ((subtask_) => {
+subtask_.controller_.abort()
+}));
+(await Promise.allSettled(ff_core_List.List_map([...task_.subtasks_], ((subtask_) => {
+return subtask_.promise_
+}))));
+self_.subtasks_.delete(task_)
+}))
+});
+return task_
 }
 
 export async function Task_throwIfAborted$(self_, $task) {
-
-            ff_core_Task.Task_throwIfAborted(self_)
-        
+const signal_ = self_.controller_.signal;
+if(signal_.aborted) {
+self_.controller_ = (new AbortController());
+signal_.throwIfAborted()
+}
 }
 
 export async function Task_abort$(self_, $task) {
-
-            self_.controller.abort()
-        
+self_.controller_.abort()
 }
 
 export async function Task_channel$(self_, capacity_ = 0, $task) {
-return ff_core_Task.Task_channel(capacity_)
+return ff_core_Channel.Channel(capacity_, ff_core_Array.new_(), (new Set()), (new Set()))
 }
 
 export async function Task_lock$(self_, $task) {
-return {owner: null, level: 0, stack: [], queue: []}
+return ff_core_Lock.Lock((void 0), 0, ff_core_Queue.new_())
 }
 
 export async function Task_now$(self_, $task) {
-return Date.now() * 0.001
+return (Date.now() * 0.001)
 }
 
 export async function Task_elapsed$(self_, $task) {
-return performance.now() * 0.001 - self_.started
+const now_ = (performance.now() * 0.001);
+return (now_ - self_.started_)
 }
 
 export async function Task_time$(self_, body_, $task) {
@@ -233,17 +254,14 @@ const successChannel_ = ff_core_Task.Task_channel(self_, 0);
 const failureChannel_ = ff_core_Task.Task_channel(self_, 0);
 ff_core_Task.Task_spawn(self_, ((t_) => {
 const channel_ = ff_core_Task.Task_channel(t_, 0);
-ff_core_Try.Try_catchAny(ff_core_Core.try_((() => {
-ff_core_List.List_each(ff_core_List.List_pairs(tasks_), ((_1) => {
-{
-const i_ = _1.first_;
-const task_ = _1.second_;
+try {
+for(let for_a = tasks_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const i_ = for_i;
+const task_ = for_a[for_i];
 ff_core_Task.Task_spawn(t_, ((_) => {
 ff_core_Channel.Channel_write(channel_, ff_core_Pair.Pair(i_, task_()))
 }))
-return
-}
-}));
+};
 const result_ = ff_core_List.List_map(ff_core_List.List_sortBy(ff_core_List.List_map(tasks_, ((_) => {
 return ff_core_Channel.Channel_read(channel_)
 })), ((_w1) => {
@@ -252,10 +270,10 @@ return _w1.first_
 return _w1.second_
 }));
 ff_core_Channel.Channel_write(successChannel_, result_)
-})), ((error_) => {
+} catch(error_) {
 ff_core_Channel.Channel_write(failureChannel_, error_);
 ff_core_Task.Task_abort(t_)
-}))
+}
 }));
 return ff_core_Channel.ChannelAction_wait(ff_core_Channel.ChannelAction_readOr(ff_core_Channel.readOr_(successChannel_, ((_w1) => {
 return _w1
@@ -270,14 +288,14 @@ const failureChannel_ = ff_core_Task.Task_channel(self_, 0);
 let live_ = tasks_.length;
 const started_ = ff_core_List.List_map(tasks_, ((task_) => {
 return ff_core_Task.Task_spawn(self_, ((_) => {
-ff_core_Try.Try_catchAny(ff_core_Core.try_((() => {
+try {
 ff_core_Channel.Channel_write(successChannel_, task_())
-})), ((e_) => {
+} catch(e_) {
 live_ -= 1;
 if((live_ === 0)) {
 ff_core_Channel.Channel_write(failureChannel_, e_)
 }
-}))
+}
 }))
 }));
 try {
@@ -287,7 +305,7 @@ return _w1
 return ff_core_Error.Error_rethrow(_w1)
 })))
 } finally {
-for(let for_i = 0, for_a = started_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = started_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const _w1 = for_a[for_i];
 ff_core_Task.Task_abort(_w1)
 }
@@ -323,17 +341,14 @@ const successChannel_ = (await ff_core_Task.Task_channel$(self_, 0, $task));
 const failureChannel_ = (await ff_core_Task.Task_channel$(self_, 0, $task));
 (await ff_core_Task.Task_spawn$(self_, (async (t_, $task) => {
 const channel_ = (await ff_core_Task.Task_channel$(t_, 0, $task));
-(await ff_core_Try.Try_catchAny$((await ff_core_Core.try_$((async ($task) => {
-(await ff_core_List.List_each$(ff_core_List.List_pairs(tasks_), (async (_1, $task) => {
-{
-const i_ = _1.first_;
-const task_ = _1.second_;
+try {
+for(let for_a = tasks_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const i_ = for_i;
+const task_ = for_a[for_i];
 (await ff_core_Task.Task_spawn$(t_, (async (_, $task) => {
 (await ff_core_Channel.Channel_write$(channel_, ff_core_Pair.Pair(i_, (await task_($task))), $task))
 }), $task))
-return
-}
-}), $task));
+};
 const result_ = ff_core_List.List_map(ff_core_List.List_sortBy((await ff_core_List.List_map$(tasks_, (async (_, $task) => {
 return (await ff_core_Channel.Channel_read$(channel_, $task))
 }), $task)), ((_w1) => {
@@ -342,10 +357,10 @@ return _w1.first_
 return _w1.second_
 }));
 (await ff_core_Channel.Channel_write$(successChannel_, result_, $task))
-}), $task)), (async (error_, $task) => {
+} catch(error_) {
 (await ff_core_Channel.Channel_write$(failureChannel_, error_, $task));
 (await ff_core_Task.Task_abort$(t_, $task))
-}), $task))
+}
 }), $task));
 return (await ff_core_Channel.ChannelAction_wait$((await ff_core_Channel.ChannelAction_readOr$((await ff_core_Channel.readOr_$(successChannel_, (async (_w1, $task) => {
 return _w1
@@ -360,14 +375,14 @@ const failureChannel_ = (await ff_core_Task.Task_channel$(self_, 0, $task));
 let live_ = tasks_.length;
 const started_ = (await ff_core_List.List_map$(tasks_, (async (task_, $task) => {
 return (await ff_core_Task.Task_spawn$(self_, (async (_, $task) => {
-(await ff_core_Try.Try_catchAny$((await ff_core_Core.try_$((async ($task) => {
+try {
 (await ff_core_Channel.Channel_write$(successChannel_, (await task_($task)), $task))
-}), $task)), (async (e_, $task) => {
+} catch(e_) {
 live_ -= 1;
 if((live_ === 0)) {
 (await ff_core_Channel.Channel_write$(failureChannel_, e_, $task))
 }
-}), $task))
+}
 }), $task))
 }), $task));
 try {
@@ -377,7 +392,7 @@ return _w1
 return ff_core_Error.Error_rethrow(_w1)
 }), $task)), $task))
 } finally {
-for(let for_i = 0, for_a = started_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = started_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const _w1 = for_a[for_i];
 (await ff_core_Task.Task_abort$(_w1, $task))
 }