firefly-compiler 0.5.35 → 0.5.37

package/output/js/ff/core/String.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,8 +94,6 @@ 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 String
 
 
@@ -106,12 +108,10 @@ return self_.length
 }
 
 export function String_grab(self_, index_) {
-
-            if(index_ < 0 || index_ >= self_.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return self_.charCodeAt(index_)
-        
+if(((index_ < 0) || (index_ >= self_.length))) {
+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 self_.charCodeAt(index_)
 }
 
 export function String_replace(self_, needle_, replacement_) {
@@ -123,7 +123,7 @@ return self_.replace(needle_, replacement_)
 }
 
 export function String_reverse(self_) {
-return [...self_].reverse().join('')
+return self_.split("").reverse().join("")
 }
 
 export function String_repeat(self_, count_) {
@@ -151,19 +151,19 @@ return self_.toUpperCase()
 }
 
 export function String_dropWhile(self_, p_) {
-
-            let i = 0
-            for(; i < self_.length && p_(self_.codePointAt(i)); i++);
-            return self_.slice(i)
-        
+let i_ = 0;
+while(((i_ < self_.length) && p_(self_.charCodeAt(i_)))) {
+i_ += 1
+};
+return self_.slice(i_)
 }
 
 export function String_takeWhile(self_, p_) {
-
-            let i = 0
-            for(; i < self_.length && p_(self_.codePointAt(i)); i++);
-            return self_.slice(0, i)
-        
+let i_ = 0;
+while(((i_ < self_.length) && p_(self_.charCodeAt(i_)))) {
+i_ += 1
+};
+return self_.slice(0, i_)
 }
 
 export function String_slice(self_, from_, until_) {
@@ -175,20 +175,14 @@ return self_.split(String.fromCharCode(char_))
 }
 
 export function String_splitFirst(self_, char_) {
-
-            const array = self_.split(String.fromCharCode(char_), 2)
-            return array.length === 2
-                ? ff_core_Option.Some(ff_core_Pair.Pair(array[0], array[1]))
-                : ff_core_Option.None()
-        
+const array_ = self_.split(String.fromCharCode(char_), 2);
+if((array_.length === 2)) {
+return ff_core_Option.Some(ff_core_Pair.Pair(array_[0], array_[1]))
+} else return ff_core_Option.None()
 }
 
 export function String_lines(self_) {
-
-            return self_.split(
-                new RegExp("[" + String.fromCharCode(13) + "]?[" + String.fromCharCode(10) + "]", "g")
-            )
-        
+return self_.split((new RegExp((((("[" + String.fromCharCode(13)) + "]?[") + String.fromCharCode(10)) + "]"), "g")))
 }
 
 export function String_dropFirst(self_, count_ = 1) {
@@ -196,80 +190,57 @@ return self_.slice(count_)
 }
 
 export function String_dropLast(self_, count_ = 1) {
-return self_.slice(0, self_.length - count_)
+return self_.slice(0, (self_.length - count_))
 }
 
 export function String_getInt(self_) {
-
-            if(self_.length == 0) {
-                return ff_core_Option.None()
-            }
-            for(let i = 0; i < self_.length; i++) {
-                const c = self_.codePointAt(i)
-                if(c < 48 || c > 57) return ff_core_Option.None()
-            }
-            return ff_core_Option.Some(parseInt(self_, 10));
-        
+if(((self_.length > 0) && ff_core_String.String_all(self_, ((c_) => {
+return ((48 <= c_) && (c_ <= 57))
+})))) {
+return ff_core_Option.Some(parseInt(self_, 10))
+} else return ff_core_Option.None()
 }
 
 export function String_getFloat(self_) {
-
-            const result = parseFloat(self_, 10);
-            if(!isFinite(result)) {
-                return ff_core_Option.None()
-            }
-            return ff_core_Option.Some(result);
-        
+const result_ = parseFloat(self_, 10);
+if(isFinite(result_)) {
+return ff_core_Option.Some(result_)
+} else return ff_core_Option.None()
 }
 
 export function String_grabInt(self_) {
-
-            if(self_.length == 0) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            for(let i = 0; i < self_.length; i++) {
-                const c = self_.codePointAt(i)
-                if(c < 48 || c > 57) ff_core_Try.internalThrowGrabException_()
-            }
-            return parseInt(self_, 10);
-        
+return ff_core_Option.Option_else(ff_core_String.String_getInt(self_), (() => {
+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)})
+}))
 }
 
 export function String_grabFloat(self_) {
-
-            const result = parseFloat(self_, 10);
-            if(!isFinite(result)) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return result;
-        
+return ff_core_Option.Option_else(ff_core_String.String_getFloat(self_), (() => {
+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)})
+}))
 }
 
 export function String_first(self_) {
-
-            return self_.length > 0
-                ? ff_core_Option.Some(self_.charCodeAt(0))
-                : ff_core_Option.None()
-        
+if((self_.length > 0)) {
+return ff_core_Option.Some(self_.charCodeAt(0))
+} else return ff_core_Option.None()
 }
 
 export function String_last(self_) {
-
-            return self_.length > 0
-                ? ff_core_Option.Some(self_.charCodeAt(self_.length - 1))
-                : ff_core_Option.None()
-        
+if((self_.length > 0)) {
+return ff_core_Option.Some(self_.charCodeAt((self_.length - 1)))
+} else return ff_core_Option.None()
 }
 
 export function String_grabFirst(self_) {
 return ff_core_Option.Option_else(ff_core_String.String_first(self_), (() => {
-return ff_core_Try.internalThrowGrabException_()
+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)})
 }))
 }
 
 export function String_grabLast(self_) {
 return ff_core_Option.Option_else(ff_core_String.String_last(self_), (() => {
-return ff_core_Try.internalThrowGrabException_()
+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)})
 }))
 }
 
@@ -287,7 +258,7 @@ return self_.endsWith(prefix_)
 
 export function String_removeFirst(self_, prefix_) {
 if(ff_core_String.String_startsWith(self_, prefix_, 0)) {
-return ff_core_Option.Some(ff_core_String.String_dropFirst(self_, ff_core_String.String_size(prefix_)))
+return ff_core_Option.Some(ff_core_String.String_dropFirst(self_, prefix_.length))
 } else {
 return ff_core_Option.None()
 }
@@ -295,194 +266,261 @@ return ff_core_Option.None()
 
 export function String_removeLast(self_, suffix_) {
 if(ff_core_String.String_endsWith(self_, suffix_)) {
-return ff_core_Option.Some(ff_core_String.String_dropLast(self_, ff_core_String.String_size(suffix_)))
+return ff_core_Option.Some(ff_core_String.String_dropLast(self_, suffix_.length))
 } else {
 return ff_core_Option.None()
 }
 }
 
 export function String_padStart(self_, length_, padding_ = " ") {
-
-            return self_.padStart(length_, padding_);
-        
+return self_.padStart(length_, padding_)
 }
 
 export function String_padEnd(self_, length_, padding_ = " ") {
-
-            return self_.padEnd(length_, padding_);
-        
+return self_.padEnd(length_, padding_)
 }
 
-export function String_any(self_, body_) {
-
-            for(let i = 0; i < self_.length; i++) {
-                if(body_(self_.charCodeAt(i))) return true;
-            }
-            return false;
-        
+export function String_each(self_, body_) {
+let i_ = 0;
+while((i_ < self_.length)) {
+body_(self_.charCodeAt(i_));
+i_ += 1
+}
+}
+
+export function String_eachWhile(self_, body_) {
+let i_ = 0;
+while((i_ < self_.length)) {
+if(body_(self_.charCodeAt(i_))) {
+i_ += 1
+} else {
+i_ = self_.length
+}
+}
 }
 
 export function String_all(self_, body_) {
-
-            for(let i = 0; i < self_.length; i++) {
-                if(!body_(self_.charCodeAt(i))) return false;
-            }
-            return true;
-        
+let result_ = true;
+ff_core_String.String_eachWhile(self_, ((x_) => {
+result_ = body_(x_);
+return result_
+}));
+return result_
+}
+
+export function String_any(self_, body_) {
+let result_ = false;
+ff_core_String.String_eachWhile(self_, ((x_) => {
+result_ = body_(x_);
+return (!result_)
+}));
+return result_
+}
+
+export function String_find(self_, body_) {
+let result_ = ff_core_Option.None();
+ff_core_String.String_eachWhile(self_, ((x_) => {
+if(body_(x_)) {
+result_ = ff_core_Option.Some(x_);
+return false
+} else {
+return true
+}
+}));
+return result_
+}
+
+export function String_indexOf(self_, needle_, position_ = 0) {
+const index_ = self_.indexOf(needle_, position_);
+if((index_ !== (-1))) {
+return ff_core_Option.Some(index_)
+} else return ff_core_Option.None()
+}
+
+export function String_indexWhere(self_, body_) {
+let i_ = (-1);
+let result_ = false;
+ff_core_String.String_eachWhile(self_, ((x_) => {
+i_ += 1;
+result_ = body_(x_);
+return (!result_)
+}));
+if(result_) {
+return ff_core_Option.Some(i_)
+} else return ff_core_Option.None()
 }
 
 export function String_filter(self_, body_) {
-
-            const result = [];
-            for(let i = 0; i < self_.length; i++) {
-                if(body_(self_.charCodeAt(i))) result.push(self_.charAt(i));
-            }
-            return result.join("");
-        
+const result_ = ff_core_Array.new_();
+ff_core_String.String_each(self_, ((x_) => {
+if(body_(x_)) {
+result_.array.push(ff_core_Char.Char_toString(x_))
+}
+}));
+return ff_core_Array.Array_join(result_, "")
 }
 
 export function String_toBuffer(self_) {
-
-            const encoded = new TextEncoder().encode(self_)
-            return new DataView(encoded.buffer, encoded.byteOffset, encoded.byteLength)
-        
+const encoded_ = (new TextEncoder()).encode(self_);
+return (new DataView(encoded_.buffer, encoded_.byteOffset, encoded_.byteLength))
 }
 
 export async function String_size$(self_, $task) {
-throw new Error('Function String_size is missing on this target in async context.');
+return self_.length
 }
 
 export async function String_grab$(self_, index_, $task) {
-throw new Error('Function String_grab is missing on this target in async context.');
+if(((index_ < 0) || (index_ >= self_.length))) {
+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 self_.charCodeAt(index_)
 }
 
 export async function String_replace$(self_, needle_, replacement_, $task) {
-throw new Error('Function String_replace is missing on this target in async context.');
+return self_.replaceAll(needle_, replacement_)
 }
 
 export async function String_replaceFirst$(self_, needle_, replacement_, $task) {
-throw new Error('Function String_replaceFirst is missing on this target in async context.');
+return self_.replace(needle_, replacement_)
 }
 
 export async function String_reverse$(self_, $task) {
-throw new Error('Function String_reverse is missing on this target in async context.');
+return self_.split("").reverse().join("")
 }
 
 export async function String_repeat$(self_, count_, $task) {
-throw new Error('Function String_repeat is missing on this target in async context.');
+return self_.repeat(count_)
 }
 
 export async function String_trim$(self_, $task) {
-throw new Error('Function String_trim is missing on this target in async context.');
+return self_.trim()
 }
 
 export async function String_trimStart$(self_, $task) {
-throw new Error('Function String_trimStart is missing on this target in async context.');
+return self_.trimStart()
 }
 
 export async function String_trimEnd$(self_, $task) {
-throw new Error('Function String_trimEnd is missing on this target in async context.');
+return self_.trimEnd()
 }
 
 export async function String_lower$(self_, $task) {
-throw new Error('Function String_lower is missing on this target in async context.');
+return self_.toLowerCase()
 }
 
 export async function String_upper$(self_, $task) {
-throw new Error('Function String_upper is missing on this target in async context.');
+return self_.toUpperCase()
 }
 
 export async function String_dropWhile$(self_, p_, $task) {
-
-            let i = 0
-            for(; i < self_.length && await p_(self_.codePointAt(i), $task); i++);
-            return self_.slice(i)
-        
+let i_ = 0;
+while(((i_ < self_.length) && (await p_(self_.charCodeAt(i_), $task)))) {
+i_ += 1
+};
+return self_.slice(i_)
 }
 
 export async function String_takeWhile$(self_, p_, $task) {
-
-            let i = 0
-            for(; i < self_.length && await p_(self_.codePointAt(i), $task); i++);
-            return self_.slice(0, i)
-        
+let i_ = 0;
+while(((i_ < self_.length) && (await p_(self_.charCodeAt(i_), $task)))) {
+i_ += 1
+};
+return self_.slice(0, i_)
 }
 
 export async function String_slice$(self_, from_, until_, $task) {
-throw new Error('Function String_slice is missing on this target in async context.');
+return self_.slice(from_, until_)
 }
 
 export async function String_split$(self_, char_, $task) {
-throw new Error('Function String_split is missing on this target in async context.');
+return self_.split(String.fromCharCode(char_))
 }
 
 export async function String_splitFirst$(self_, char_, $task) {
-throw new Error('Function String_splitFirst is missing on this target in async context.');
+const array_ = self_.split(String.fromCharCode(char_), 2);
+if((array_.length === 2)) {
+return ff_core_Option.Some(ff_core_Pair.Pair(array_[0], array_[1]))
+} else return ff_core_Option.None()
 }
 
 export async function String_lines$(self_, $task) {
-throw new Error('Function String_lines is missing on this target in async context.');
+return self_.split((new RegExp((((("[" + String.fromCharCode(13)) + "]?[") + String.fromCharCode(10)) + "]"), "g")))
 }
 
 export async function String_dropFirst$(self_, count_ = 1, $task) {
-throw new Error('Function String_dropFirst is missing on this target in async context.');
+return self_.slice(count_)
 }
 
 export async function String_dropLast$(self_, count_ = 1, $task) {
-throw new Error('Function String_dropLast is missing on this target in async context.');
+return self_.slice(0, (self_.length - count_))
 }
 
 export async function String_getInt$(self_, $task) {
-throw new Error('Function String_getInt is missing on this target in async context.');
+if(((self_.length > 0) && ff_core_String.String_all(self_, ((c_) => {
+return ((48 <= c_) && (c_ <= 57))
+})))) {
+return ff_core_Option.Some(parseInt(self_, 10))
+} else return ff_core_Option.None()
 }
 
 export async function String_getFloat$(self_, $task) {
-throw new Error('Function String_getFloat is missing on this target in async context.');
+const result_ = parseFloat(self_, 10);
+if(isFinite(result_)) {
+return ff_core_Option.Some(result_)
+} else return ff_core_Option.None()
 }
 
 export async function String_grabInt$(self_, $task) {
-throw new Error('Function String_grabInt is missing on this target in async context.');
+return ff_core_Option.Option_else(ff_core_String.String_getInt(self_), (() => {
+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)})
+}))
 }
 
 export async function String_grabFloat$(self_, $task) {
-throw new Error('Function String_grabFloat is missing on this target in async context.');
+return ff_core_Option.Option_else(ff_core_String.String_getFloat(self_), (() => {
+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)})
+}))
 }
 
 export async function String_first$(self_, $task) {
-throw new Error('Function String_first is missing on this target in async context.');
+if((self_.length > 0)) {
+return ff_core_Option.Some(self_.charCodeAt(0))
+} else return ff_core_Option.None()
 }
 
 export async function String_last$(self_, $task) {
-throw new Error('Function String_last is missing on this target in async context.');
+if((self_.length > 0)) {
+return ff_core_Option.Some(self_.charCodeAt((self_.length - 1)))
+} else return ff_core_Option.None()
 }
 
 export async function String_grabFirst$(self_, $task) {
 return ff_core_Option.Option_else(ff_core_String.String_first(self_), (() => {
-return ff_core_Try.internalThrowGrabException_()
+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)})
 }))
 }
 
 export async function String_grabLast$(self_, $task) {
 return ff_core_Option.Option_else(ff_core_String.String_last(self_), (() => {
-return ff_core_Try.internalThrowGrabException_()
+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)})
 }))
 }
 
 export async function String_contains$(self_, substring_, $task) {
-throw new Error('Function String_contains is missing on this target in async context.');
+return self_.includes(substring_)
 }
 
 export async function String_startsWith$(self_, prefix_, offset_ = 0, $task) {
-throw new Error('Function String_startsWith is missing on this target in async context.');
+return self_.startsWith(prefix_, offset_)
 }
 
 export async function String_endsWith$(self_, prefix_, $task) {
-throw new Error('Function String_endsWith is missing on this target in async context.');
+return self_.endsWith(prefix_)
 }
 
 export async function String_removeFirst$(self_, prefix_, $task) {
 if(ff_core_String.String_startsWith(self_, prefix_, 0)) {
-return ff_core_Option.Some(ff_core_String.String_dropFirst(self_, ff_core_String.String_size(prefix_)))
+return ff_core_Option.Some(ff_core_String.String_dropFirst(self_, prefix_.length))
 } else {
 return ff_core_Option.None()
 }
@@ -490,50 +528,103 @@ return ff_core_Option.None()
 
 export async function String_removeLast$(self_, suffix_, $task) {
 if(ff_core_String.String_endsWith(self_, suffix_)) {
-return ff_core_Option.Some(ff_core_String.String_dropLast(self_, ff_core_String.String_size(suffix_)))
+return ff_core_Option.Some(ff_core_String.String_dropLast(self_, suffix_.length))
 } else {
 return ff_core_Option.None()
 }
 }
 
 export async function String_padStart$(self_, length_, padding_ = " ", $task) {
-throw new Error('Function String_padStart is missing on this target in async context.');
+return self_.padStart(length_, padding_)
 }
 
 export async function String_padEnd$(self_, length_, padding_ = " ", $task) {
-throw new Error('Function String_padEnd is missing on this target in async context.');
+return self_.padEnd(length_, padding_)
 }
 
-export async function String_any$(self_, body_, $task) {
-
-            for(let i = 0; i < self_.length; i++) {
-                if(await body_(self_.charCodeAt(i), $task)) return true;
-            }
-            return false;
-        
+export async function String_each$(self_, body_, $task) {
+let i_ = 0;
+while((i_ < self_.length)) {
+(await body_(self_.charCodeAt(i_), $task));
+i_ += 1
+}
+}
+
+export async function String_eachWhile$(self_, body_, $task) {
+let i_ = 0;
+while((i_ < self_.length)) {
+if((await body_(self_.charCodeAt(i_), $task))) {
+i_ += 1
+} else {
+i_ = self_.length
+}
+}
 }
 
 export async function String_all$(self_, body_, $task) {
-
-            for(let i = 0; i < self_.length; i++) {
-                if(!await body_(self_.charCodeAt(i), $task)) return false;
-            }
-            return true;
-        
+let result_ = true;
+(await ff_core_String.String_eachWhile$(self_, (async (x_, $task) => {
+result_ = (await body_(x_, $task));
+return result_
+}), $task));
+return result_
+}
+
+export async function String_any$(self_, body_, $task) {
+let result_ = false;
+(await ff_core_String.String_eachWhile$(self_, (async (x_, $task) => {
+result_ = (await body_(x_, $task));
+return (!result_)
+}), $task));
+return result_
+}
+
+export async function String_find$(self_, body_, $task) {
+let result_ = ff_core_Option.None();
+(await ff_core_String.String_eachWhile$(self_, (async (x_, $task) => {
+if((await body_(x_, $task))) {
+result_ = ff_core_Option.Some(x_);
+return false
+} else {
+return true
+}
+}), $task));
+return result_
+}
+
+export async function String_indexOf$(self_, needle_, position_ = 0, $task) {
+const index_ = self_.indexOf(needle_, position_);
+if((index_ !== (-1))) {
+return ff_core_Option.Some(index_)
+} else return ff_core_Option.None()
+}
+
+export async function String_indexWhere$(self_, body_, $task) {
+let i_ = (-1);
+let result_ = false;
+(await ff_core_String.String_eachWhile$(self_, (async (x_, $task) => {
+i_ += 1;
+result_ = (await body_(x_, $task));
+return (!result_)
+}), $task));
+if(result_) {
+return ff_core_Option.Some(i_)
+} else return ff_core_Option.None()
 }
 
 export async function String_filter$(self_, body_, $task) {
-
-            const result = [];
-            for(let i = 0; i < self_.length; i++) {
-                if(await body_(self_.charCodeAt(i))) result.push(self_.charAt(i));
-            }
-            return result.join("");
-        
+const result_ = ff_core_Array.new_();
+(await ff_core_String.String_each$(self_, (async (x_, $task) => {
+if((await body_(x_, $task))) {
+result_.array.push(ff_core_Char.Char_toString(x_))
+}
+}), $task));
+return ff_core_Array.Array_join(result_, "")
 }
 
 export async function String_toBuffer$(self_, $task) {
-throw new Error('Function String_toBuffer is missing on this target in async context.');
+const encoded_ = (new TextEncoder()).encode(self_);
+return (new DataView(encoded_.buffer, encoded_.byteOffset, encoded_.byteLength))
 }
 
 export const ff_core_Any_HasAnyTag$ff_core_String_String = {