firefly-compiler 0.5.35 → 0.5.37

package/output/js/ff/core/Buffer.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,91 +94,129 @@ 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 Buffer
 
 
 
 
 export function new_(size_, shared_ = false) {
-return new DataView(shared_ ? new SharedArrayBuffer(size_) : new ArrayBuffer(size_))
+return (new DataView((shared_
+? (new SharedArrayBuffer(size_))
+: (new ArrayBuffer(size_)))))
 }
 
 export function fromByteList_(array_) {
-return new DataView(new Uint8Array(array_).buffer)
+return (new DataView(Uint8Array(array_).buffer))
 }
 
 export function fromBufferList_(array_) {
-
-        let length = 0
-        for(let b of array_) length += b.byteLength
-        const arrayBuffer = new ArrayBuffer(length);
-        const result = new Uint8Array(arrayBuffer)
-        let offset = 0
-        for(let b of array_) {
-            result.set(new Uint8Array(b.buffer, b.byteOffset, b.byteLength), offset)
-            offset += b.byteLength
-        }
-        return new DataView(arrayBuffer)
-    
+let length_ = 0;
+for(let for_a = array_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const _w1 = for_a[for_i];
+length_ += _w1.byteLength
+};
+const arrayBuffer_ = (new ArrayBuffer(length_));
+const result_ = (new Uint8Array(arrayBuffer_));
+let offset_ = 0;
+for(let for_a = array_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const b_ = for_a[for_i];
+result_.set((new Uint8Array(b_.buffer, b_.byteOffset, b_.byteLength)), offset_);
+offset_ += b_.byteLength
+};
+return (new DataView(arrayBuffer_))
 }
 
 export function fromHex_(hex_) {
-
-        const hexValues = hex_.match(/.{1,2}/g) || []
-        const numbers = hexValues.map(value => parseInt(value, 16))
-        return new DataView(new Uint8Array(numbers).buffer)
-    
+const byteCount_ = ff_core_Float.Float_toInt(ff_core_Float.Float_ceil((hex_.length * 0.5)));
+const arrayBuffer_ = (new ArrayBuffer(byteCount_));
+const result_ = (new Uint8Array(arrayBuffer_));
+for(let for_i = 0, for_e = byteCount_; for_i < for_e; for_i++) {
+const i_ = for_i;
+result_[i_] = parseInt(hex_.slice((i_ * 2), ((i_ * 2) + 2)), 16)
+};
+return (new DataView(arrayBuffer_))
 }
 
 export function fromBase64_(base64_) {
-
-        const binaryString = atob(base64_)
-        const dataView = new DataView(new ArrayBuffer(binaryString.length))
-        dataView.setUint8(binaryString.split('').map(char => char.charCodeAt(0)))
-        return dataView
-    
+const binaryString_ = atob(base64_);
+const bytes_ = Uint8Array.from(binaryString_, ((char_) => {
+return char_.CharCodeAt(0)
+}));
+return (new DataView(bytes_.buffer))
 }
 
 export async function new_$(size_, shared_ = false, $task) {
-throw new Error('Function new is missing on this target in async context.');
+return (new DataView((shared_
+? (new SharedArrayBuffer(size_))
+: (new ArrayBuffer(size_)))))
 }
 
 export async function fromByteList_$(array_, $task) {
-throw new Error('Function fromByteList is missing on this target in async context.');
+return (new DataView(Uint8Array(array_).buffer))
 }
 
 export async function fromBufferList_$(array_, $task) {
-throw new Error('Function fromBufferList is missing on this target in async context.');
+let length_ = 0;
+for(let for_a = array_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const _w1 = for_a[for_i];
+length_ += _w1.byteLength
+};
+const arrayBuffer_ = (new ArrayBuffer(length_));
+const result_ = (new Uint8Array(arrayBuffer_));
+let offset_ = 0;
+for(let for_a = array_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const b_ = for_a[for_i];
+result_.set((new Uint8Array(b_.buffer, b_.byteOffset, b_.byteLength)), offset_);
+offset_ += b_.byteLength
+};
+return (new DataView(arrayBuffer_))
 }
 
 export async function fromHex_$(hex_, $task) {
-throw new Error('Function fromHex is missing on this target in async context.');
+const byteCount_ = ff_core_Float.Float_toInt(ff_core_Float.Float_ceil((hex_.length * 0.5)));
+const arrayBuffer_ = (new ArrayBuffer(byteCount_));
+const result_ = (new Uint8Array(arrayBuffer_));
+for(let for_i = 0, for_e = byteCount_; for_i < for_e; for_i++) {
+const i_ = for_i;
+result_[i_] = parseInt(hex_.slice((i_ * 2), ((i_ * 2) + 2)), 16)
+};
+return (new DataView(arrayBuffer_))
 }
 
 export async function fromBase64_$(base64_, $task) {
-throw new Error('Function fromBase64 is missing on this target in async context.');
+const binaryString_ = atob(base64_);
+const bytes_ = Uint8Array.from(binaryString_, ((char_) => {
+return char_.CharCodeAt(0)
+}));
+return (new DataView(bytes_.buffer))
 }
 
 export function Buffer_grabUint64(self_, byteOffset_, littleEndian_ = true) {
-
-            const high = self_.getUint32(byteOffset_ + (littleEndian_ ? 4 : 0), littleEndian_)
-            const low = self_.getUint32(byteOffset_ + (littleEndian_ ? 0 : 4), littleEndian_)
-            const result = (high * 0x100000000) + low
-            if(!Number.isSafeInteger(result)) throw 'grabUint64 out of range (consider grabBigUint64)'
-            return result
-        
+const high_ = self_.getUint32((byteOffset_ + (littleEndian_
+? 4
+: 0)), littleEndian_);
+const low_ = self_.getUint32((byteOffset_ + (littleEndian_
+? 0
+: 4)), littleEndian_);
+const result_ = ((high_ * 0x100000000) + low_);
+if((!Number.isSafeInteger(result_))) {
+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 Buffer_grabInt64(self_, byteOffset_, littleEndian_ = true) {
-
-            const high = self_.getInt32(byteOffset_ + (littleEndian_ ? 4 : 0), littleEndian_)
-            const low = self_.getUint32(byteOffset_ + (littleEndian_ ? 0 : 4), littleEndian_)
-            const result = (high * 0x100000000) + low
-            if(!Number.isSafeInteger(result)) throw 'grabInt64 out of range (consider grabBigInt64)'
-            return result
-        
+const high_ = self_.getInt32((byteOffset_ + (littleEndian_
+? 4
+: 0)), littleEndian_);
+const low_ = self_.getUint32((byteOffset_ + (littleEndian_
+? 0
+: 4)), littleEndian_);
+const result_ = ((high_ * 0x100000000) + low_);
+if((!Number.isSafeInteger(result_))) {
+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 Buffer_grabFloat32(self_, byteOffset_, littleEndian_ = true) {
@@ -210,17 +252,21 @@ return self_.getUint8(byteOffset_)
 }
 
 export function Buffer_setUint64(self_, byteOffset_, value_, littleEndian_ = true) {
-
-            self_.setUint32(byteOffset_ + (littleEndian_ ? 4 : 0), (value_ >>> 16) >>> 16, littleEndian_)
-            self_.setUint32(byteOffset_ + (littleEndian_ ? 0 : 4), value_ & 0xffffffff, littleEndian_)
-        
+self_.setUint32((byteOffset_ + (littleEndian_
+? 4
+: 0)), ((value_ >>> 16) >>> 16), littleEndian_);
+self_.setUint32((byteOffset_ + (littleEndian_
+? 0
+: 4)), (value_ & 0xffffffff), littleEndian_)
 }
 
 export function Buffer_setInt64(self_, byteOffset_, value_, littleEndian_ = true) {
-
-            self_.setUint32(byteOffset_ + (littleEndian_ ? 4 : 0), (value_ >> 16) >> 16, littleEndian_)
-            self_.setUint32(byteOffset_ + (littleEndian_ ? 0 : 4), value_ & 0xffffffff, littleEndian_)
-        
+self_.setUint32((byteOffset_ + (littleEndian_
+? 4
+: 0)), ((value_ >> 16) >> 16), littleEndian_);
+self_.setUint32((byteOffset_ + (littleEndian_
+? 0
+: 4)), (value_ & 0xffffffff), littleEndian_)
 }
 
 export function Buffer_setFloat32(self_, byteOffset_, value_, littleEndian_ = true) {
@@ -256,11 +302,9 @@ self_.setUint8(byteOffset_, value_)
 }
 
 export function Buffer_setAll(self_, byteOffset_, buffer_) {
-
-            const sourceBuffer = new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength)
-            const targetBuffer = new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength)
-            targetBuffer.set(sourceBuffer, byteOffset_)
-        
+const sourceBuffer_ = (new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength));
+const targetBuffer_ = (new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength));
+targetBuffer_.set(sourceBuffer_, byteOffset_)
 }
 
 export function Buffer_size(self_) {
@@ -268,162 +312,205 @@ return self_.byteLength
 }
 
 export function Buffer_shared(self_) {
-return typeof SharedArrayBuffer !== 'undefined' && self_.buffer instanceof SharedArrayBuffer
+return (((typeof SharedArrayBuffer) !== "undefined") && (self_.buffer instanceof SharedArrayBuffer))
 }
 
 export function Buffer_view(self_, begin_, end_) {
-return new DataView(self_.buffer, self_.byteOffset + begin_, end_ - begin_)
+return (new DataView(self_.buffer, (self_.byteOffset + begin_), (end_ - begin_)))
 }
 
 export function Buffer_copy(self_) {
-return new DataView(self_.buffer.slice(self_.byteOffset, self_.byteOffset + self_.byteLength))
+return (new DataView(self_.buffer.slice(self_.byteOffset, (self_.byteOffset + self_.byteLength))))
 }
 
 export function Buffer_toString(self_, encoding_ = "utf8") {
-
-            if(encoding_ === "utf8") {
-                if(typeof TextDecoder.ffSingleton === 'undefined') TextDecoder.ffSingleton = new TextDecoder()
-                return TextDecoder.ffSingleton.decode(self_)
-            }
-            return new TextDecoder().decode(self_)
-        
+if((encoding_ === "utf8")) {
+if(((typeof TextDecoder.ffSingleton) === "undefined")) {
+TextDecoder.ffSingleton = (new TextDecoder())
+};
+TextDecoder.ffSingleton.decode(self_)
+};
+return (new TextDecoder()).decode(self_)
 }
 
 export function Buffer_toByteArray(self_) {
-return [...new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength)]
+return [...(new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength))]
 }
 
 export function Buffer_toHex(self_) {
-
-            let hex = ''
-            for (let i = 0; i < self_.byteLength; i++) {
-                hex += self_.getUint8(i).toString(16).padStart(2, '0')
-            }
-            return hex
-        
+let hex_ = "";
+for(let for_i = 0, for_e = self_.byteLength; for_i < for_e; for_i++) {
+const i_ = for_i;
+hex_ = (hex_ + self_.getUint8(i_).toString(16).padStart(2, "0"))
+};
+return hex_
 }
 
 export function Buffer_toBase64(self_) {
-
-            const view = new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength);
-            return btoa(String.fromCharCode(...view));
-        
+const view_ = (new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength));
+const binaryString_ = (new TextDecoder("latin1")).decode(view_);
+return btoa(binaryString_)
 }
 
 export async function Buffer_grabUint64$(self_, byteOffset_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_grabUint64 is missing on this target in async context.');
+const high_ = self_.getUint32((byteOffset_ + (littleEndian_
+? 4
+: 0)), littleEndian_);
+const low_ = self_.getUint32((byteOffset_ + (littleEndian_
+? 0
+: 4)), littleEndian_);
+const result_ = ((high_ * 0x100000000) + low_);
+if((!Number.isSafeInteger(result_))) {
+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 Buffer_grabInt64$(self_, byteOffset_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_grabInt64 is missing on this target in async context.');
+const high_ = self_.getInt32((byteOffset_ + (littleEndian_
+? 4
+: 0)), littleEndian_);
+const low_ = self_.getUint32((byteOffset_ + (littleEndian_
+? 0
+: 4)), littleEndian_);
+const result_ = ((high_ * 0x100000000) + low_);
+if((!Number.isSafeInteger(result_))) {
+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 Buffer_grabFloat32$(self_, byteOffset_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_grabFloat32 is missing on this target in async context.');
+return self_.getFloat32(byteOffset_, littleEndian_)
 }
 
 export async function Buffer_grabFloat64$(self_, byteOffset_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_grabFloat64 is missing on this target in async context.');
+return self_.getFloat64(byteOffset_, littleEndian_)
 }
 
 export async function Buffer_grabInt16$(self_, byteOffset_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_grabInt16 is missing on this target in async context.');
+return self_.getInt16(byteOffset_, littleEndian_)
 }
 
 export async function Buffer_grabInt32$(self_, byteOffset_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_grabInt32 is missing on this target in async context.');
+return self_.getInt32(byteOffset_, littleEndian_)
 }
 
 export async function Buffer_grabInt8$(self_, byteOffset_, $task) {
-throw new Error('Function Buffer_grabInt8 is missing on this target in async context.');
+return self_.getInt8(byteOffset_)
 }
 
 export async function Buffer_grabUint16$(self_, byteOffset_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_grabUint16 is missing on this target in async context.');
+return self_.getUint16(byteOffset_, littleEndian_)
 }
 
 export async function Buffer_grabUint32$(self_, byteOffset_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_grabUint32 is missing on this target in async context.');
+return self_.getUint32(byteOffset_, littleEndian_)
 }
 
 export async function Buffer_grabUint8$(self_, byteOffset_, $task) {
-throw new Error('Function Buffer_grabUint8 is missing on this target in async context.');
+return self_.getUint8(byteOffset_)
 }
 
 export async function Buffer_setUint64$(self_, byteOffset_, value_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_setUint64 is missing on this target in async context.');
+self_.setUint32((byteOffset_ + (littleEndian_
+? 4
+: 0)), ((value_ >>> 16) >>> 16), littleEndian_);
+self_.setUint32((byteOffset_ + (littleEndian_
+? 0
+: 4)), (value_ & 0xffffffff), littleEndian_)
 }
 
 export async function Buffer_setInt64$(self_, byteOffset_, value_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_setInt64 is missing on this target in async context.');
+self_.setUint32((byteOffset_ + (littleEndian_
+? 4
+: 0)), ((value_ >> 16) >> 16), littleEndian_);
+self_.setUint32((byteOffset_ + (littleEndian_
+? 0
+: 4)), (value_ & 0xffffffff), littleEndian_)
 }
 
 export async function Buffer_setFloat32$(self_, byteOffset_, value_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_setFloat32 is missing on this target in async context.');
+self_.setFloat32(byteOffset_, value_, littleEndian_)
 }
 
 export async function Buffer_setFloat64$(self_, byteOffset_, value_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_setFloat64 is missing on this target in async context.');
+self_.setFloat64(byteOffset_, value_, littleEndian_)
 }
 
 export async function Buffer_setInt16$(self_, byteOffset_, value_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_setInt16 is missing on this target in async context.');
+self_.setInt16(byteOffset_, value_, littleEndian_)
 }
 
 export async function Buffer_setInt32$(self_, byteOffset_, value_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_setInt32 is missing on this target in async context.');
+self_.setInt32(byteOffset_, value_, littleEndian_)
 }
 
 export async function Buffer_setInt8$(self_, byteOffset_, value_, $task) {
-throw new Error('Function Buffer_setInt8 is missing on this target in async context.');
+self_.setInt8(byteOffset_, value_)
 }
 
 export async function Buffer_setUint16$(self_, byteOffset_, value_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_setUint16 is missing on this target in async context.');
+self_.setUint16(byteOffset_, value_, littleEndian_)
 }
 
 export async function Buffer_setUint32$(self_, byteOffset_, value_, littleEndian_ = true, $task) {
-throw new Error('Function Buffer_setUint32 is missing on this target in async context.');
+self_.setUint32(byteOffset_, value_, littleEndian_)
 }
 
 export async function Buffer_setUint8$(self_, byteOffset_, value_, $task) {
-throw new Error('Function Buffer_setUint8 is missing on this target in async context.');
+self_.setUint8(byteOffset_, value_)
 }
 
 export async function Buffer_setAll$(self_, byteOffset_, buffer_, $task) {
-throw new Error('Function Buffer_setAll is missing on this target in async context.');
+const sourceBuffer_ = (new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength));
+const targetBuffer_ = (new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength));
+targetBuffer_.set(sourceBuffer_, byteOffset_)
 }
 
 export async function Buffer_size$(self_, $task) {
-throw new Error('Function Buffer_size is missing on this target in async context.');
+return self_.byteLength
 }
 
 export async function Buffer_shared$(self_, $task) {
-throw new Error('Function Buffer_shared is missing on this target in async context.');
+return (((typeof SharedArrayBuffer) !== "undefined") && (self_.buffer instanceof SharedArrayBuffer))
 }
 
 export async function Buffer_view$(self_, begin_, end_, $task) {
-throw new Error('Function Buffer_view is missing on this target in async context.');
+return (new DataView(self_.buffer, (self_.byteOffset + begin_), (end_ - begin_)))
 }
 
 export async function Buffer_copy$(self_, $task) {
-throw new Error('Function Buffer_copy is missing on this target in async context.');
+return (new DataView(self_.buffer.slice(self_.byteOffset, (self_.byteOffset + self_.byteLength))))
 }
 
 export async function Buffer_toString$(self_, encoding_ = "utf8", $task) {
-throw new Error('Function Buffer_toString is missing on this target in async context.');
+if((encoding_ === "utf8")) {
+if(((typeof TextDecoder.ffSingleton) === "undefined")) {
+TextDecoder.ffSingleton = (new TextDecoder())
+};
+TextDecoder.ffSingleton.decode(self_)
+};
+return (new TextDecoder()).decode(self_)
 }
 
 export async function Buffer_toByteArray$(self_, $task) {
-throw new Error('Function Buffer_toByteArray is missing on this target in async context.');
+return [...(new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength))]
 }
 
 export async function Buffer_toHex$(self_, $task) {
-throw new Error('Function Buffer_toHex is missing on this target in async context.');
+let hex_ = "";
+for(let for_i = 0, for_e = self_.byteLength; for_i < for_e; for_i++) {
+const i_ = for_i;
+hex_ = (hex_ + self_.getUint8(i_).toString(16).padStart(2, "0"))
+};
+return hex_
 }
 
 export async function Buffer_toBase64$(self_, $task) {
-throw new Error('Function Buffer_toBase64 is missing on this target in async context.');
+const view_ = (new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength));
+const binaryString_ = (new TextDecoder("latin1")).decode(view_);
+return btoa(binaryString_)
 }
 
 export const ff_core_Show_Show$ff_core_Buffer_Buffer = {
@@ -437,38 +524,103 @@ return ((`Buffer.fromHex("` + ff_core_Buffer.Buffer_toHex(value_)) + `")`)
 
 export const ff_core_Equal_Equal$ff_core_Buffer_Buffer = {
 equals_(x_, y_) {
-
-            if(x_.buffer.byteLength !== y_.buffer.byteLength) return false
-            if(x_.buffer === y_.buffer) return true
-            for(let i = 0; i + 4 <= x_.buffer.byteLength; i += 4) {
-                if(x_.getInt32(i) !== y_.getInt32(i)) return false
-            }
-            for(; i < x_.buffer.byteLength; i++) {
-                if(x_.getUint8(i) !== y_.getUint8(i)) return false
-            }
-            return true
-        
+if((ff_core_Buffer.Buffer_size(x_) !== ff_core_Buffer.Buffer_size(y_))) {
+return false
+} else {
+if((x_ === y_)) {
+return true
+} else {
+let i_ = 0;
+let same_ = true;
+while((((i_ + 4) < ff_core_Buffer.Buffer_size(x_)) && same_)) {
+same_ = (x_.getInt32(i_) === y_.getInt32(i_));
+i_ += 4
+};
+if((!same_)) {
+return false
+} else {
+for(let for_i = i_, for_e = ff_core_Buffer.Buffer_size(x_); for_i < for_e; for_i++) {
+const i_ = for_i;
+same_ = (x_.getUint8(i_) === y_.getUint8(i_));
+if(!same_) break
+};
+return same_
+}
+}
+}
 },
 async equals_$(x_, y_, $task) {
-throw new Error('Function equals is missing on this target in async context.');
+if((ff_core_Buffer.Buffer_size(x_) !== ff_core_Buffer.Buffer_size(y_))) {
+return false
+} else {
+if((x_ === y_)) {
+return true
+} else {
+let i_ = 0;
+let same_ = true;
+while((((i_ + 4) < ff_core_Buffer.Buffer_size(x_)) && same_)) {
+same_ = (x_.getInt32(i_) === y_.getInt32(i_));
+i_ += 4
+};
+if((!same_)) {
+return false
+} else {
+for(let for_i = i_, for_e = ff_core_Buffer.Buffer_size(x_); for_i < for_e; for_i++) {
+const i_ = for_i;
+same_ = (x_.getUint8(i_) === y_.getUint8(i_));
+if(!same_) break
+};
+return same_
+}
+}
+}
 }
 };
 
 export const ff_core_Ordering_Order$ff_core_Buffer_Buffer = {
 compare_(x_, y_) {
-
-            if(x_.buffer === y_.buffer) return ff_core_Ordering.OrderingSame()
-            const minLength = Math.min(x_.buffer.byteLength, y_.buffer.byteLength)
-            for(let i = 0; i < minLength; i++) {
-                if(x_.getUint8(i) !== y_.getUint8(i)) {
-                    return ff_core_Ordering.fromInt_(x_.getUint8(i) - y_.getUint8(i))
-                }
-            }
-            return ff_core_Ordering.fromInt_(x_.buffer.byteLength - y_.buffer.byteLength)
-        
+if((x_ === y_)) {
+return ff_core_Ordering.OrderingSame()
+} else {
+const minLength_ = ff_core_Int.Int_min(ff_core_Buffer.Buffer_size(x_), ff_core_Buffer.Buffer_size(y_));
+let ordering_ = ff_core_Ordering.OrderingSame();
+for(let for_i = 0, for_e = minLength_; for_i < for_e; for_i++) {
+const i_ = for_i;
+if((x_.getUint8(i_) !== x_.getUint8(i_))) {
+ordering_ = ff_core_Ordering.fromInt_((x_.getUint8(i_) - y_.getUint8(i_)));
+if(!false) break
+} else {
+if(!true) break
+}
+};
+if((ordering_ === ff_core_Ordering.OrderingSame())) {
+return ff_core_Ordering.fromInt_((ff_core_Buffer.Buffer_size(x_) - ff_core_Buffer.Buffer_size(y_)))
+} else {
+return ordering_
+}
+}
 },
 async compare_$(x_, y_, $task) {
-throw new Error('Function compare is missing on this target in async context.');
+if((x_ === y_)) {
+return ff_core_Ordering.OrderingSame()
+} else {
+const minLength_ = ff_core_Int.Int_min(ff_core_Buffer.Buffer_size(x_), ff_core_Buffer.Buffer_size(y_));
+let ordering_ = ff_core_Ordering.OrderingSame();
+for(let for_i = 0, for_e = minLength_; for_i < for_e; for_i++) {
+const i_ = for_i;
+if((x_.getUint8(i_) !== x_.getUint8(i_))) {
+ordering_ = ff_core_Ordering.fromInt_((x_.getUint8(i_) - y_.getUint8(i_)));
+if(!false) break
+} else {
+if(!true) break
+}
+};
+if((ordering_ === ff_core_Ordering.OrderingSame())) {
+return ff_core_Ordering.fromInt_((ff_core_Buffer.Buffer_size(x_) - ff_core_Buffer.Buffer_size(y_)))
+} else {
+return ordering_
+}
+}
 }
 };