firefly-compiler 0.5.35 → 0.5.37

package/core/Crypto.ff

@@ -1,96 +1,94 @@
-capability Crypto {}
-
-extend self: Crypto {
-    
-    randomUuid(): String
-        target js async """
-            return self_.randomUUID();
-        """
-    
-    randomBuffer(size: Int): Buffer {
-        let buffer = Buffer.new(size)
-        self.randomizeBuffer(buffer)
-        buffer
-    }
-
-    randomizeBuffer(buffer: Buffer): Unit
-        target js async """
-            self_.getRandomValues(new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength));
-        """
-
-    hmacSha256(key: Buffer, buffer: Buffer): Buffer
-        target js async """
-            const cryptoKey = await self_.subtle.importKey(
-                'raw',
-                key_,
-                {name: 'HMAC', hash: {name: 'SHA-256'}},
-                false, 
-                ['sign']
-            );
-            const signature = await self_.subtle.sign(
-                'HMAC', 
-                cryptoKey, 
-                buffer_
-            );
-            return new DataView(signature);
-        """
-        
-    sha256(buffer: Buffer): Buffer 
-        target js async """
-            let hash = await self_.subtle.digest('SHA-256', buffer_);
-            return new DataView(hash);
-        """
-
-    hashPassword(password: String, iterations: Int = 600000): String {
-        let salt = self.randomBuffer(16)
-        let hash = internalHashPassword(self, salt, password.toBuffer(), iterations)
-        "$pbkdf2-sha256-hex$" + iterations + "$" + salt.toHex() + "$" + hash.toHex()
-    }
-    
-    checkPassword(password: String, passwordHash: String): Bool {
-        passwordHash.split('$').{
-            | ["", "pbkdf2-sha256-hex", iterationsText, saltText, hashText] {
-                iterationsText.getInt() | Some(iterations)
-            } =>
-                let computedHash = 
-                    internalHashPassword(self, Buffer.fromHex(saltText), password.toBuffer(), iterations)
-                let hash = Buffer.fromHex(hashText)
-                self.constantTimeEquals(computedHash, hash)
-            | _ => False
-        }
-    }
-
-    constantTimeEquals(buffer1: Buffer, buffer2: Buffer): Bool {
-        if(buffer1.size() != buffer2.size()) {False} else: 
-        mutable v = 0
-        mutable i = 0
-        while {i < buffer1.size()} {
-            v = v.bitOr(buffer1.grabUint8(i).bitXor(buffer2.grabUint8(i)))
-            i += 1
-        }
-        v == 0
-    }
-
-}
-
-internalHashPassword(system: Crypto, salt: Buffer, password: Buffer, iterations: Int): Buffer
-    target js async """
-        const keyMaterial = await crypto.subtle.importKey(
-            'raw',
-            password_,
-            {name: 'PBKDF2'},
-            false,
-            ['deriveBits']
-        );
-        const hashBuffer = await crypto.subtle.deriveBits(
-            {
-                name: 'PBKDF2',
-                salt: salt_,
-                iterations: iterations_,
-                hash: 'SHA-256'
-            },
-            keyMaterial,
-            256
-        );
-        return new DataView(hashBuffer);
-    """
+capability Crypto {}
+
+extend self: Crypto {
+    
+    randomUuid(): String {
+        self!->randomUUID()?
+    }
+    
+    randomBuffer(size: Int): Buffer {
+        let buffer = Buffer.new(size)
+        self.randomizeBuffer(buffer)
+        buffer
+    }
+
+    randomizeBuffer(buffer: Buffer): Unit {
+        self!->getRandomValues(Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength))
+    }
+
+    hmacSha256(key: Buffer, buffer: Buffer): Buffer {
+        Js.throwIfCancelled()
+        let cryptoKey = Js.await(self!->subtle->importKey(
+            "raw"
+            key!
+            Js->(name = "HMAC", hash = Js->(name = "SHA-256"))
+            False
+            ["sign"]
+        ))
+        let signature = Js.await(self!->subtle->sign(
+            "HMAC"
+            cryptoKey
+            buffer!
+        )) 
+        Js->DataView->(signature)?
+    }
+        
+    sha256(buffer: Buffer): Buffer {
+        Js.throwIfCancelled()
+        let hash = Js.await(self!->subtle->digest("SHA-256", buffer))
+        Js->DataView->(hash)?
+    }
+
+    hashPassword(password: String, iterations: Int = 600000): String {
+        let salt = self.randomBuffer(16)
+        let hash = internalHashPassword(self, salt, password.toBuffer(), iterations)
+        "$pbkdf2-sha256-hex$" + iterations + "$" + salt.toHex() + "$" + hash.toHex()
+    }
+    
+    checkPassword(password: String, passwordHash: String): Bool {
+        passwordHash.split('$').{
+            | ["", "pbkdf2-sha256-hex", iterationsText, saltText, hashText] {
+                iterationsText.getInt() | Some(iterations)
+            } =>
+                let computedHash = 
+                    internalHashPassword(self, Buffer.fromHex(saltText), password.toBuffer(), iterations)
+                let hash = Buffer.fromHex(hashText)
+                self.constantTimeEquals(computedHash, hash)
+            | _ => False
+        }
+    }
+
+    constantTimeEquals(buffer1: Buffer, buffer2: Buffer): Bool {
+        if(buffer1.size() != buffer2.size()) {False} else: 
+        mutable v = 0
+        mutable i = 0
+        while {i < buffer1.size()} {
+            v = v.bitOr(buffer1.grabUint8(i).bitXor(buffer2.grabUint8(i)))
+            i += 1
+        }
+        v == 0
+    }
+
+}
+
+internalHashPassword(system: Crypto, salt: Buffer, password: Buffer, iterations: Int): Buffer {
+    Js.throwIfCancelled()
+    let keyMaterial = Js.await(system!->subtle->importKey(
+        "raw"
+        password!
+        Js->(name = "PBKDF2")
+        False
+        ["deriveBits"]
+    ))
+    let hashBuffer = Js.await(system!->subtle->deriveBits(
+        Js->(
+            name = "PBKDF2"
+            salt = salt
+            iterations = iterations
+            hash = "SHA-256"
+        )
+        keyMaterial
+        256
+    ))
+    Js->DataView->(hashBuffer)?
+}

package/core/Equal.ff

@@ -1,36 +1,41 @@
-trait T: Equal {
-    equals(x: T, y: T): Bool
-}
-
-notEquals[T: Equal](x: T, y: T): Bool {
-    !equals(x, y)
-}
-
-instance Nothing: Equal {
-    equals(x: Nothing, y: Nothing): Bool {True}
-}
-
-instance Bool: Equal {
-    equals(x: Bool, y: Bool): Bool
-        target js sync """return x_ === y_"""
-}
-
-instance Char: Equal {
-    equals(x: Char, y: Char): Bool
-        target js sync """return x_ === y_"""
-}
-
-instance Int: Equal {
-    equals(x: Int, y: Int): Bool
-        target js sync """return x_ === y_"""
-}
-
-instance Float: Equal {
-    equals(x: Float, y: Float): Bool
-        target js sync """return x_ === y_"""
-}
-
-instance String: Equal {
-    equals(x: String, y: String): Bool
-        target js sync """return x_ === y_"""
-}
+trait T: Equal {
+    equals(x: T, y: T): Bool
+}
+
+notEquals[T: Equal](x: T, y: T): Bool {
+    !equals(x, y)
+}
+
+instance Nothing: Equal {
+    equals(x: Nothing, y: Nothing): Bool {True}
+}
+
+instance Bool: Equal {
+    equals(x: Bool, y: Bool): Bool {
+        x!.equals(y)
+    }
+}
+
+instance Char: Equal {
+    equals(x: Char, y: Char): Bool {
+        x!.equals(y)
+    }
+}
+
+instance Int: Equal {
+    equals(x: Int, y: Int): Bool {
+        x!.equals(y)
+    }
+}
+
+instance Float: Equal {
+    equals(x: Float, y: Float): Bool {
+        x!.equals(y)
+    }
+}
+
+instance String: Equal {
+    equals(x: String, y: String): Bool {
+        x!.equals(y)
+    }
+}

package/core/Error.ff

@@ -2,19 +2,24 @@ data Error {}
 
 extend self: Error {
 
-    rethrow[T](): T
-        target js sync "throw self_"
+    rethrow[T](): T {
+        Js.throw(self!)
+    }
 
-    name(): String
-        target js sync "return self_.name || ''"
+    name(): String {
+        self!->name.coalesce("")?
+    }
 
-    message(): String
-        target js sync "return self_.message || ''"
+    message(): String {
+        self!->message.coalesce("")?
+    }
 
-    stack(): String
-        target js sync "return self_.stack || ''"
+    stack(): String {
+        self!->stack.coalesce("")?
+    }
 
-    exception(): Option[Any]
-        target js sync "return self_.ffException ? ff_core_Option.Some(self_.ffException) : ff_core_Option.None()"
+    exception(): Option[Any] {
+        if(!self!->ffException.isNullOrUndefined()) {self!->ffException?}
+    }
 
 }

package/core/FileHandle.ff

@@ -2,46 +2,54 @@ capability FileHandle {}
 
 extend self: FileHandle {
 
-    close(): Unit
-        target js async """
-            await self_.close()
-        """
+    close(): Unit {
+        Js.await(self!->close())
+    }
 
-    read(buffer: Buffer, offset: Int = 0, length: Option[Int] = None, position: Option[Int] = None): Unit
-        target js async """
-            ff_core_Task.Task_throwIfAborted($task)
-            await self_.read(buffer_, {offset: offset_, length: length.value_, position: position.value_})
-        """
+    read(buffer: Buffer, offset: Int = 0, length: Option[Int] = None, position: Option[Int] = None): Unit {
+        Js.throwIfCancelled()
+        Js.await(self!->read(buffer, Js->(
+            offset = offset
+            length = length.map {_!}.else {Js.undefined()}
+            position = position.map {_!}.else {Js.undefined()}
+        )))
+    }
 
-    write(buffer: Buffer, offset: Int = 0, length: Option[Int] = None, position: Option[Int] = None): Unit
-        target js async """
-            ff_core_Task.Task_throwIfAborted($task)
-            await self_.write(buffer_, offset_, length.value_, position.value_)
-        """
-
-    writeText(text: String, position: Option[Int] = None, encoding: String = "utf8"): Unit
-        target js async """
-            ff_core_Task.Task_throwIfAborted($task)
-            await self_.write(text, position.value_, encoding_)
-        """
+    write(buffer: Buffer, offset: Int = 0, length: Option[Int] = None, position: Option[Int] = None): Unit {
+        Js.throwIfCancelled()
+        Js.await(self!->write(
+            buffer
+            offset
+            length.map {_!}.else {Js.undefined()}
+            position.map {_!}.else {Js.undefined()}
+        ))
+    }
+    
+    writeText(text: String, position: Option[Int] = None, encoding: String = "utf8"): Unit {
+        Js.throwIfCancelled()
+        Js.await(self!->write(
+            text
+            position.map {_!}.else {Js.undefined()}
+            encoding
+        ))
+    }
         
-    writeLine(text: String, position: Option[Int] = None, encoding: String = "utf8"): Unit
-        target js async """
-            ff_core_Task.Task_throwIfAborted($task)
-            await self_.write(text + "\\n", position.value_, encoding_)
-        """
+    writeLine(text: String, position: Option[Int] = None, encoding: String = "utf8"): Unit {
+        self.writeText(text + "\n", position, encoding)
+    }
         
-    truncate(length: Int = 0): Unit
-        target js async """
-            ff_core_Task.Task_throwIfAborted($task)
-            await self_.truncate(length_)
-        """
-
-    sync(dataOnly: Bool = False): Unit
-        target js async """
-            ff_core_Task.Task_throwIfAborted($task)
-            if(dataOnly_) await self_.datasync()
-            else await self_.sync()
-        """
+    truncate(length: Int = 0): Unit {
+        Js.throwIfCancelled()
+        Js.await(self!->truncate(length))
+    }
+    
+    sync(dataOnly: Bool = False): Unit {
+        Js.throwIfCancelled()
+        if(dataOnly) {
+            Js.await(self!->datasync())
+        } else {
+            Js.await(self!->sync())
+        }
+    }
 
 }