firefly-compiler 0.4.36 → 0.4.40

package/bin/Release.ff

@@ -1,12 +1,28 @@
+dependency ff:s3:0.0.0
+import S3 from ff:s3
+
 nodeMain(system: NodeSystem) {
-    run(system, "node", ["output/js/ff/compiler/Main.mjs", "bootstrap"], system.path(".."))
-    run(system, "node", ["output/js/ff/compiler/Main.mjs", "bootstrap"], system.path(".."))
-    run(system, "node", ["output/js/ff/compiler/Main.mjs", "bootstrap"], system.path(".."))
-    bumpMinorVersion(system, system.path("../package.json"))
-    bumpMinorVersion(system, system.path("../vscode/package.json"))
-    run(system, "npm", ["publish"], system.path(".."))
-    run(system, "vsce", ["publish"], system.path("../vscode"))
-    // tar gz core etc. and upload to s3
+    system.arguments().{
+        | [] => 
+        | [awsUser, awsKey] =>
+            run(system, "node", ["output/js/ff/compiler/Main.mjs", "bootstrap"], system.path(".."))
+            run(system, "node", ["output/js/ff/compiler/Main.mjs", "bootstrap"], system.path(".."))
+            run(system, "node", ["output/js/ff/compiler/Main.mjs", "bootstrap"], system.path(".."))
+            bumpMinorVersion(system, system.path("../package.json"))
+            bumpMinorVersion(system, system.path("../vscode/package.json"))
+            //run(system, "npm", ["publish"], system.path(".."))
+            //run(system, "vsce", ["publish"], system.path("../vscode"))
+            let coreTemporary = system.path("../core/.firefly/temporary")
+            if(!coreTemporary.exists()) {coreTemporary.createDirectory()}
+            let coreTarGz = coreTemporary.slash("ff_core_0_0_0.tar.gz")
+            if(coreTarGz.exists()) {
+                coreTarGz.delete()
+                system.writeLine("Deleted " + coreTarGz.absolute())    
+            }
+            internalMakeTarGz(coreTarGz, system.path("../core"))
+            system.writeLine("Created " + coreTarGz.absolute())
+            //S3.put(system, awsUser, awsKey, )
+    }
 }
 
 run(system: NodeSystem, command: String, arguments: List[String], workingDirectory: Path) {
@@ -47,3 +63,9 @@ bumpMinorVersion(system: NodeSystem, packageJsonPath: Path) {
     }
     packageJsonPath.writeText(newContent)
 }
+
+internalMakeTarGz(tarGzPath: Path, path: Path): Unit
+    target node async """
+        import * as tar from 'tar'
+        await tar.create({gzip: true, file: tarGzPath_}, [path_]);
+    """

package/core/BrowserSystem.ff

@@ -8,6 +8,9 @@ extend self: BrowserSystem {
     mainTask(): Task
         target js async "return self_.task_"
 
+    crypto(): Crypto
+        target js async "return (typeof globalThis !== 'undefined' ? globalThis : window).crypto"
+        
     js(): JsSystem
         target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
         

package/core/Buffer.ff

@@ -143,10 +143,10 @@ extend self: Buffer {
 
 }
 
-fromByteArray(array: List[Int]): Buffer
+fromByteList(array: List[Int]): Buffer
     target js sync "return new DataView(new Uint8Array(array_).buffer)"
 
-fromBufferArray(array: List[Buffer]): Buffer
+fromBufferList(array: List[Buffer]): Buffer
     target js sync """
         let length = 0
         for(let b of array_) length += b.byteLength
@@ -162,7 +162,7 @@ fromBufferArray(array: List[Buffer]): Buffer
 
 fromHex(hex: String): Buffer
     target js sync """
-        const hexValues = hexString.match(/.{1,2}/g) || []
+        const hexValues = hex_.match(/.{1,2}/g) || []
         const numbers = hexValues.map(value => parseInt(value, 16))
         return new DataView(new Uint8Array(numbers).buffer)
     """

package/core/BuildSystem.ff

@@ -38,6 +38,9 @@ extend self: BuildSystem {
     mainTask(): Task
         target js async "return self_.task_"
 
+    crypto(): Crypto
+        target js async "return (typeof globalThis !== 'undefined' ? globalThis : window).crypto"
+        
 }
 
 extend self: BrowserCode {

package/core/Crypto.ff

@@ -41,44 +41,54 @@ extend self: Crypto {
             return new DataView(hash);
         """
 
-    makePasswordHash(password: String, iterations: Int = 100000): String {
+    hashPassword(password: String, iterations: Int = 600000, pepper: String = ""): String {
         let salt = self.randomBuffer(16)
-        let hash = internalMakePasswordHash(salt, password.toBuffer(), iterations)
-        "PSG_" + iterations + "_" + salt.toHex() + "_" + hash.toHex()
+        let hash = internalHashPassword(self, salt, (password + pepper).toBuffer(), iterations)
+        "$pbkdf2-sha256$" + iterations + "$" + salt.toHex() + "$" + hash.toHex()
     }
     
-    checkPasswordHash(password: String, passwordHash: String): Bool {
-        passwordHash.split('_').{
-            | ["PSG", iterationsText, saltText, hashText] {iterationsText.getInt() | Some(iterations)} =>
-                let computedHash = internalMakePasswordHash(Buffer.fromHex(saltText), password.toBuffer(), iterations)
+    checkPassword(
+        password: String, 
+        passwordHash: String, 
+        pepper: String = "", 
+        minIterations: Int = 100000, 
+        maxIterations: Int = 2000000
+    ): Bool {
+        passwordHash.split('$').{
+            | ["", "pbkdf2-sha256", iterationsText, saltText, hashText] {iterationsText.getInt() | Some(iterations)} {
+                iterations >= minIterations && iterations <= maxIterations
+            } =>
+                let computedHash = 
+                    internalHashPassword(self, Buffer.fromHex(saltText), (password + pepper).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))) 
+            v = v.bitOr(buffer1.grabUint8(i).bitXor(buffer2.grabUint8(i)))
+            i += 1
         }
         v == 0
     }
 
 }
 
-internalMakePasswordHash(salt: Buffer, password: Buffer, iterations: Int): Buffer
+internalHashPassword(system: Crypto, salt: Buffer, password: Buffer, iterations: Int): Buffer
     target js async """
         const keyMaterial = await crypto.subtle.importKey(
             'raw',
             password_,
             {name: 'PBKDF2'},
             false,
-            ['deriveKey']
+            ['deriveBits']
         );
-        const derivedKey = await crypto.subtle.deriveKey(
+        const hashBuffer = await crypto.subtle.deriveBits(
             {
                 name: 'PBKDF2',
                 salt: salt_,
@@ -86,10 +96,7 @@ internalMakePasswordHash(salt: Buffer, password: Buffer, iterations: Int): Buffe
                 hash: 'SHA-256'
             },
             keyMaterial,
-            {name: 'AES-GCM', length: 256},
-            true,
-            ['encrypt', 'decrypt']
+            256
         );
-        const hashBuffer = await crypto.subtle.exportKey('raw', derivedKey);
         return new DataView(hashBuffer);
     """

package/core/Instant.ff

@@ -1,9 +1,26 @@
 newtype Instant(since1970: Duration)
 
+fromIso(date: String): Option[Instant] {
+    let zone = date.endsWith("Z") || date.contains("+") || date.dropWhile {_ != 'T'}.contains("-")
+    if(zone && date.takeWhile {_ != 'T'}.contains("-") && date.contains("T") && date.contains(":")) {
+        internalParseDate(date)
+    }
+}
+
 extend self: Instant {
 
     add(duration: Duration): Instant {
         Instant(Duration(self.since1970.seconds + duration.seconds))
     }
+    
+    toIso(): String
+        target js sync """
+            return new Date(self_ * 1000).toISOString();
+        """
 
 }
+
+internalParseDate(date: String): Instant
+    target js sync """
+        return Date.parse(date_) * 0.001;
+    """

package/core/NodeSystem.ff

@@ -45,7 +45,7 @@ extend self: NodeSystem {
     mainTask(): Task
         target js async "return self_.task_"
 
-    crypto()
+    crypto(): Crypto
         target js async "return (typeof globalThis !== 'undefined' ? globalThis : window).crypto"
 
     js(): JsSystem

package/core/Stream.ff

@@ -372,7 +372,7 @@ extend self: Stream[Buffer] {
     toBuffer(): Buffer {
         let builder = Array.new()
         self.each {builder.push(_)}
-        Buffer.fromBufferArray(builder.drain())
+        Buffer.fromBufferList(builder.drain())
     }
 
     toString(encoding: String = "utf8"): String {

package/experimental/random/RunLength.ff

@@ -1,12 +1,12 @@
 main(system: NodeSystem) {
-    let inBuffers = 1.to(100).map {_ => Buffer.fromByteArray([5, 5, 3, 1, 2].toArray())}
+    let inBuffers = 1.to(100).map {_ => Buffer.fromByteList([5, 5, 3, 1, 2].toArray())}
     let inStream = inBuffers.toStream()
     let outStream = toRunLength(inStream, 3)
     printRunLength(outStream)
 }
 
 printRunLength(outStream: Stream[Buffer]) {
-    let buffer = Buffer.fromBufferArray(outStream.toArray())
+    let buffer = Buffer.fromBufferList(outStream.toArray())
     Log.debug(buffer.toHex())
     let stack = Stack.make()
     mutable i = 0
@@ -14,7 +14,7 @@ printRunLength(outStream: Stream[Buffer]) {
         1.to(buffer.grabUint8(i)).each {_ => stack.push(buffer.grabUint8(i + 1))}
         i += 2
     }
-    Log.debug(Buffer.fromByteArray(stack.drain()).toHex())
+    Log.debug(Buffer.fromByteList(stack.drain()).toHex())
 }
 
 toRunLength(stream: Stream[Buffer], bufferSize: Int = 65536): Stream[Buffer] {

package/lsp/LanguageServer.ff

@@ -158,7 +158,7 @@ parseRequestHeaders(input: Stream[Buffer]): Pair[Map[String, String], Stream[Buf
         offset += 1
     }
     buffers.push(buffer.view(0, offset))
-    let headers = Buffer.fromBufferArray(buffers.drain()).toString()
+    let headers = Buffer.fromBufferList(buffers.drain()).toString()
     let map = headers.lines().pairs().filter {_.second.size() != 0}.map {| Pair(i, line) =>
         line.splitFirst(':').else {
             throw(BadRequestException("Invalid header at line " + i + " '" + line + "'"))
@@ -173,7 +173,7 @@ parseRequestBody(contentLength: Int, input: Stream[Buffer]): Pair[Json, Stream[B
     } catchAny {error =>
         throw(BadRequestException("End of input while parsing request body"))
     } grab()
-    let body = Buffer.fromBufferArray(bodyPair.first).toString()
+    let body = Buffer.fromBufferList(bodyPair.first).toString()
     let json = Json.read(body).else {
         throw(BadRequestException("Invalid JSON in request body: " + body))
     }

package/output/js/ff/core/BrowserSystem.mjs

@@ -107,6 +107,10 @@ export function BrowserSystem_mainTask(self_) {
 throw new Error('Function BrowserSystem_mainTask is missing on this target in sync context.');
 }
 
+export function BrowserSystem_crypto(self_) {
+throw new Error('Function BrowserSystem_crypto is missing on this target in sync context.');
+}
+
 export function BrowserSystem_js(self_) {
 throw new Error('Function BrowserSystem_js is missing on this target in sync context.');
 }
@@ -135,6 +139,10 @@ export async function BrowserSystem_mainTask$(self_, $task) {
 return self_.task_
 }
 
+export async function BrowserSystem_crypto$(self_, $task) {
+return (typeof globalThis !== 'undefined' ? globalThis : window).crypto
+}
+
 export async function BrowserSystem_js$(self_, $task) {
 return typeof globalThis !== 'undefined' ? globalThis : window
 }

package/output/js/ff/core/Buffer.mjs

@@ -99,11 +99,11 @@ export function new_(size_, shared_ = false) {
 return new DataView(shared_ ? new SharedArrayBuffer(size_) : new ArrayBuffer(size_))
 }
 
-export function fromByteArray_(array_) {
+export function fromByteList_(array_) {
 return new DataView(new Uint8Array(array_).buffer)
 }
 
-export function fromBufferArray_(array_) {
+export function fromBufferList_(array_) {
 
         let length = 0
         for(let b of array_) length += b.byteLength
@@ -120,7 +120,7 @@ export function fromBufferArray_(array_) {
 
 export function fromHex_(hex_) {
 
-        const hexValues = hexString.match(/.{1,2}/g) || []
+        const hexValues = hex_.match(/.{1,2}/g) || []
         const numbers = hexValues.map(value => parseInt(value, 16))
         return new DataView(new Uint8Array(numbers).buffer)
     
@@ -139,12 +139,12 @@ export async function new_$(size_, shared_ = false, $task) {
 throw new Error('Function new is missing on this target in async context.');
 }
 
-export async function fromByteArray_$(array_, $task) {
-throw new Error('Function fromByteArray is missing on this target in async context.');
+export async function fromByteList_$(array_, $task) {
+throw new Error('Function fromByteList is missing on this target in async context.');
 }
 
-export async function fromBufferArray_$(array_, $task) {
-throw new Error('Function fromBufferArray is missing on this target in async context.');
+export async function fromBufferList_$(array_, $task) {
+throw new Error('Function fromBufferList is missing on this target in async context.');
 }
 
 export async function fromHex_$(hex_, $task) {

package/output/js/ff/core/BuildSystem.mjs

@@ -241,6 +241,10 @@ export function BuildSystem_mainTask(self_) {
 throw new Error('Function BuildSystem_mainTask is missing on this target in sync context.');
 }
 
+export function BuildSystem_crypto(self_) {
+throw new Error('Function BuildSystem_crypto is missing on this target in sync context.');
+}
+
 export async function BuildSystem_compileForBrowser$(self_, mainFile_, $task) {
 (await ff_core_BuildSystem.internalCompile_$(self_, (await ff_core_BuildSystem.internalPath_$(self_, mainFile_, $task)), "browser", $task));
 const streams_ = (await ff_core_BuildSystem.internalListDirectory_$((await ff_core_BuildSystem.internalPath_$(self_, ".firefly/output/browser", $task)), $task));
@@ -273,6 +277,10 @@ export async function BuildSystem_mainTask$(self_, $task) {
 return self_.task_
 }
 
+export async function BuildSystem_crypto$(self_, $task) {
+return (typeof globalThis !== 'undefined' ? globalThis : window).crypto
+}
+
 export function BrowserCode_assets(self_) {
 return self_.assetSystem_
 }

package/output/js/ff/core/Crypto.mjs

@@ -95,20 +95,20 @@ import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
 
 
-export function internalMakePasswordHash_(salt_, password_, iterations_) {
-throw new Error('Function internalMakePasswordHash is missing on this target in sync context.');
+export function internalHashPassword_(system_, salt_, password_, iterations_) {
+throw new Error('Function internalHashPassword is missing on this target in sync context.');
 }
 
-export async function internalMakePasswordHash_$(salt_, password_, iterations_, $task) {
+export async function internalHashPassword_$(system_, salt_, password_, iterations_, $task) {
 
         const keyMaterial = await crypto.subtle.importKey(
             'raw',
             password_,
             {name: 'PBKDF2'},
             false,
-            ['deriveKey']
+            ['deriveBits']
         );
-        const derivedKey = await crypto.subtle.deriveKey(
+        const hashBuffer = await crypto.subtle.deriveBits(
             {
                 name: 'PBKDF2',
                 salt: salt_,
@@ -116,11 +116,8 @@ export async function internalMakePasswordHash_$(salt_, password_, iterations_,
                 hash: 'SHA-256'
             },
             keyMaterial,
-            {name: 'AES-GCM', length: 256},
-            true,
-            ['encrypt', 'decrypt']
+            256
         );
-        const hashBuffer = await crypto.subtle.exportKey('raw', derivedKey);
         return new DataView(hashBuffer);
     
 }
@@ -147,27 +144,29 @@ export function Crypto_sha256(self_, buffer_) {
 throw new Error('Function Crypto_sha256 is missing on this target in sync context.');
 }
 
-export function Crypto_makePasswordHash(self_, password_, iterations_ = 100000) {
+export function Crypto_hashPassword(self_, password_, iterations_ = 600000, pepper_ = "") {
 const salt_ = ff_core_Crypto.Crypto_randomBuffer(self_, 16);
-const hash_ = ff_core_Crypto.internalMakePasswordHash_(salt_, ff_core_String.String_toBuffer(password_), iterations_);
-return ((((("PSG_" + iterations_) + "_") + ff_core_Buffer.Buffer_toHex(salt_)) + "_") + ff_core_Buffer.Buffer_toHex(hash_))
+const hash_ = ff_core_Crypto.internalHashPassword_(self_, salt_, ff_core_String.String_toBuffer((password_ + pepper_)), iterations_);
+return ((((("$pbkdf2-sha256$" + iterations_) + "$") + ff_core_Buffer.Buffer_toHex(salt_)) + "$") + ff_core_Buffer.Buffer_toHex(hash_))
 }
 
-export function Crypto_checkPasswordHash(self_, password_, passwordHash_) {
+export function Crypto_checkPassword(self_, password_, passwordHash_, pepper_ = "", minIterations_ = 100000, maxIterations_ = 2000000) {
 {
-const _1 = ff_core_String.String_split(passwordHash_, 95);
-if(_1.length === 4 && _1[0] === "PSG") {
-const iterationsText_ = _1[1];
-const saltText_ = _1[2];
-const hashText_ = _1[3];
-const _guard1 = ff_core_String.String_getInt(iterationsText_);
-if(_guard1.Some) {
-const iterations_ = _guard1.value_;
-const computedHash_ = ff_core_Crypto.internalMakePasswordHash_(ff_core_Buffer.fromHex_(saltText_), ff_core_String.String_toBuffer(password_), iterations_);
+const _1 = ff_core_String.String_split(passwordHash_, 36);
+if(_1.length === 5 && _1[0] === "" && _1[1] === "pbkdf2-sha256") {
+const iterationsText_ = _1[2];
+const saltText_ = _1[3];
+const hashText_ = _1[4];
+const _guard2 = ff_core_String.String_getInt(iterationsText_);
+if(_guard2.Some) {
+const iterations_ = _guard2.value_;
+if(((iterations_ >= minIterations_) && (iterations_ <= maxIterations_))) {
+const computedHash_ = ff_core_Crypto.internalHashPassword_(self_, ff_core_Buffer.fromHex_(saltText_), ff_core_String.String_toBuffer((password_ + pepper_)), iterations_);
 const hash_ = ff_core_Buffer.fromHex_(hashText_);
 return ff_core_Crypto.Crypto_constantTimeEquals(self_, computedHash_, hash_)
 }
 }
+}
 {
 return false
 }
@@ -181,7 +180,8 @@ return false
 let v_ = 0;
 let i_ = 0;
 while((i_ < ff_core_Buffer.Buffer_size(buffer1_))) {
-v_ = ff_core_Int.Int_bitOr(v_, ff_core_Int.Int_bitXor(ff_core_Buffer.Buffer_grabUint8(buffer1_, i_), ff_core_Buffer.Buffer_grabUint8(buffer2_, i_)))
+v_ = ff_core_Int.Int_bitOr(v_, ff_core_Int.Int_bitXor(ff_core_Buffer.Buffer_grabUint8(buffer1_, i_), ff_core_Buffer.Buffer_grabUint8(buffer2_, i_)));
+i_ += 1
 };
 return (v_ === 0)
 }
@@ -230,27 +230,29 @@ export async function Crypto_sha256$(self_, buffer_, $task) {
         
 }
 
-export async function Crypto_makePasswordHash$(self_, password_, iterations_ = 100000, $task) {
+export async function Crypto_hashPassword$(self_, password_, iterations_ = 600000, pepper_ = "", $task) {
 const salt_ = (await ff_core_Crypto.Crypto_randomBuffer$(self_, 16, $task));
-const hash_ = ff_core_Crypto.internalMakePasswordHash_(salt_, ff_core_String.String_toBuffer(password_), iterations_);
-return ((((("PSG_" + iterations_) + "_") + ff_core_Buffer.Buffer_toHex(salt_)) + "_") + ff_core_Buffer.Buffer_toHex(hash_))
+const hash_ = (await ff_core_Crypto.internalHashPassword_$(self_, salt_, ff_core_String.String_toBuffer((password_ + pepper_)), iterations_, $task));
+return ((((("$pbkdf2-sha256$" + iterations_) + "$") + ff_core_Buffer.Buffer_toHex(salt_)) + "$") + ff_core_Buffer.Buffer_toHex(hash_))
 }
 
-export async function Crypto_checkPasswordHash$(self_, password_, passwordHash_, $task) {
+export async function Crypto_checkPassword$(self_, password_, passwordHash_, pepper_ = "", minIterations_ = 100000, maxIterations_ = 2000000, $task) {
 {
-const _1 = ff_core_String.String_split(passwordHash_, 95);
-if(_1.length === 4 && _1[0] === "PSG") {
-const iterationsText_ = _1[1];
-const saltText_ = _1[2];
-const hashText_ = _1[3];
-const _guard1 = ff_core_String.String_getInt(iterationsText_);
-if(_guard1.Some) {
-const iterations_ = _guard1.value_;
-const computedHash_ = ff_core_Crypto.internalMakePasswordHash_(ff_core_Buffer.fromHex_(saltText_), ff_core_String.String_toBuffer(password_), iterations_);
+const _1 = ff_core_String.String_split(passwordHash_, 36);
+if(_1.length === 5 && _1[0] === "" && _1[1] === "pbkdf2-sha256") {
+const iterationsText_ = _1[2];
+const saltText_ = _1[3];
+const hashText_ = _1[4];
+const _guard2 = ff_core_String.String_getInt(iterationsText_);
+if(_guard2.Some) {
+const iterations_ = _guard2.value_;
+if(((iterations_ >= minIterations_) && (iterations_ <= maxIterations_))) {
+const computedHash_ = (await ff_core_Crypto.internalHashPassword_$(self_, ff_core_Buffer.fromHex_(saltText_), ff_core_String.String_toBuffer((password_ + pepper_)), iterations_, $task));
 const hash_ = ff_core_Buffer.fromHex_(hashText_);
 return (await ff_core_Crypto.Crypto_constantTimeEquals$(self_, computedHash_, hash_, $task))
 }
 }
+}
 {
 return false
 }
@@ -264,7 +266,8 @@ return false
 let v_ = 0;
 let i_ = 0;
 while((i_ < ff_core_Buffer.Buffer_size(buffer1_))) {
-v_ = ff_core_Int.Int_bitOr(v_, ff_core_Int.Int_bitXor(ff_core_Buffer.Buffer_grabUint8(buffer1_, i_), ff_core_Buffer.Buffer_grabUint8(buffer2_, i_)))
+v_ = ff_core_Int.Int_bitOr(v_, ff_core_Int.Int_bitXor(ff_core_Buffer.Buffer_grabUint8(buffer1_, i_), ff_core_Buffer.Buffer_grabUint8(buffer2_, i_)));
+i_ += 1
 };
 return (v_ === 0)
 }

package/output/js/ff/core/Instant.mjs

@@ -94,18 +94,56 @@ import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
 
 
+export function fromIso_(date_) {
+const zone_ = ((ff_core_String.String_endsWith(date_, "Z") || ff_core_String.String_contains(date_, "+")) || ff_core_String.String_contains(ff_core_String.String_dropWhile(date_, ((_w1) => {
+return (_w1 !== 84)
+})), "-"));
+if((((zone_ && ff_core_String.String_contains(ff_core_String.String_takeWhile(date_, ((_w1) => {
+return (_w1 !== 84)
+})), "-")) && ff_core_String.String_contains(date_, "T")) && ff_core_String.String_contains(date_, ":"))) {
+return ff_core_Option.Some(ff_core_Instant.internalParseDate_(date_))
+} else return ff_core_Option.None()
+}
 
+export function internalParseDate_(date_) {
 
+        return Date.parse(date_) * 0.001;
+    
+}
 
+export async function fromIso_$(date_, $task) {
+const zone_ = ((ff_core_String.String_endsWith(date_, "Z") || ff_core_String.String_contains(date_, "+")) || ff_core_String.String_contains(ff_core_String.String_dropWhile(date_, ((_w1) => {
+return (_w1 !== 84)
+})), "-"));
+if((((zone_ && ff_core_String.String_contains(ff_core_String.String_takeWhile(date_, ((_w1) => {
+return (_w1 !== 84)
+})), "-")) && ff_core_String.String_contains(date_, "T")) && ff_core_String.String_contains(date_, ":"))) {
+return ff_core_Option.Some(ff_core_Instant.internalParseDate_(date_))
+} else return ff_core_Option.None()
+}
+
+export async function internalParseDate_$(date_, $task) {
+throw new Error('Function internalParseDate is missing on this target in async context.');
+}
 
 export function Instant_add(self_, duration_) {
 return (self_ + duration_)
 }
 
+export function Instant_toIso(self_) {
+
+            return new Date(self_ * 1000).toISOString();
+        
+}
+
 export async function Instant_add$(self_, duration_, $task) {
 return (self_ + duration_)
 }
 
+export async function Instant_toIso$(self_, $task) {
+throw new Error('Function Instant_toIso is missing on this target in async context.');
+}
+
 
 
 

package/output/js/ff/core/Stream.mjs

@@ -1098,7 +1098,7 @@ const builder_ = ff_core_Array.new_();
 ff_core_Stream.Stream_each(self_, ((_w1) => {
 ff_core_Array.Array_push(builder_, _w1)
 }));
-return ff_core_Buffer.fromBufferArray_(ff_core_Array.Array_drain(builder_))
+return ff_core_Buffer.fromBufferList_(ff_core_Array.Array_drain(builder_))
 }
 
 export function Stream_toString(self_, encoding_ = "utf8") {
@@ -1133,7 +1133,7 @@ const builder_ = ff_core_Array.new_();
 (await ff_core_Stream.Stream_each$(self_, (async (_w1, $task) => {
 ff_core_Array.Array_push(builder_, _w1)
 }), $task));
-return ff_core_Buffer.fromBufferArray_(ff_core_Array.Array_drain(builder_))
+return ff_core_Buffer.fromBufferList_(ff_core_Array.Array_drain(builder_))
 }
 
 export async function Stream_toString$(self_, encoding_ = "utf8", $task) {

package/package.json

@@ -1,29 +1,29 @@
 {
-  "name": "firefly-compiler",
-  "displayName": "Firefly Compiler",
-  "description": "Firefly compiler",
-  "author": "Firefly team",
-  "license": "MIT",
-  "version": "0.4.36",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Ahnfelt/firefly-boot"
-  },
-  "publisher": "firefly-team",
-  "categories": [
-    "Programming Languages"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "main": "./vscode/client/out/extension",
-  "icon": "./vscode/icons/firefly-logo.png",
-  "dependencies": {
-    "pkg": "^5.8.0",
-    "tar": "^6.1.11",
-    "esbuild": "^0.21.3"
-  },
-  "bin": {
-    "firefly": "./bin/firefly.mjs"
-  }
+    "name": "firefly-compiler",
+    "displayName": "Firefly Compiler",
+    "description": "Firefly compiler",
+    "author": "Firefly team",
+    "license": "MIT",
+    "version": "0.4.40",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Ahnfelt/firefly-boot"
+    },
+    "publisher": "firefly-team",
+    "categories": [
+        "Programming Languages"
+    ],
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "main": "./vscode/client/out/extension",
+    "icon": "./vscode/icons/firefly-logo.png",
+    "dependencies": {
+        "pkg": "^5.8.0",
+        "tar": "^6.1.11",
+        "esbuild": "^0.21.3"
+    },
+    "bin": {
+        "firefly": "./bin/firefly.mjs"
+    }
 }

package/s3/.firefly/package.ff

@@ -0,0 +1 @@
+package ff:s3:0.0.0

package/{experimental/s3 → s3}/S3.ff

@@ -10,7 +10,7 @@ put(
 ): Unit {
     let now = system.mainTask().now()
     let amzDate = toIsoString(now)
-    let contentHash = Digest.sha256(body).toHex()
+    let contentHash = system.crypto().sha256(body).toHex()
     let host = bucket + ".s3.amazonaws.com"
     let encodedKey = encode(objectKey)
     let canonicalHeaders = [

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.36",
+    "version": "0.4.40",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/crypto/SubtleCrypto.ff

@@ -1,149 +0,0 @@
-import Crypto from ff:core
-
-capability SubtleCrypto(crypto: Crypto)
-
-data CryptoKey {}
-
-data CryptoKeyUsages(
-    encrypt: Bool = False
-    decrypt: Bool = False
-    sign: Bool = False
-    verify: Bool = False
-    deriveKey: Bool = False
-    deriveBits: Bool = False
-    wrapKey: Bool = False
-    unwrapKey: Bool = False
-)
-
-class CryptoCipher {
-    RsaOaep(label: Option[String] = None)
-    AesCtr(counter: Buffer, length: Int)
-    AesCbc(initializationVector: Buffer)
-    AesGcm(initializationVector: Buffer, additionalData: Option[Buffer] = None, tagLength: Int = 128)
-}
-
-class CryptoDeriver {
-    Ecdh(public: CryptoKey)
-    Hkdf(hash: CryptoDigest, salt: Buffer, info: Buffer)
-    Pbkdf2(hash: CryptoDigest, salt: Buffer, iterations: Int)
-}
-
-class CryptoGenerator {
-    HmacGenerator(hash: CryptoDigest, length: Option[Int])
-    AesCtrGenerator(length: Int)
-    AesCbcGenerator(length: Int)
-    AesGcmGenerator(length: Int)
-    AesKwGenerator(length: Int)
-    HkdfGenerator(hash: CryptoDigest, salt: Buffer, info: Buffer)
-    Pbkdf2Generator(hash: CryptoDigest, salt: Buffer, iterations: Int)
-}
-
-class CryptoSigner {
-    RsassaPkcs1V15
-    RsaPss(saltLength: Int)
-    Ecdsa(hash: CryptoDigest)
-    Hmac
-}
-
-data CryptoDigest {
-    Sha512
-    Sha384
-    Sha256
-    Sha1
-}
-
-extend self: SubtleCrypto {
-
-    encrypt(algorithm: CryptoCipher, key: CryptoKey, data: Buffer): Buffer
-        target js async """
-            const a = internalAlgorithm_(algorithm_);
-            return new DataView(await self_.encrypt(a, key_, data_));
-        """
-
-    decrypt(algorithm: CryptoCipher, key: CryptoKey, data: Buffer): Buffer
-        target js async """
-            const a = internalAlgorithm_(algorithm_);
-            return new DataView(await self_.decrypt(a, key_, data_));
-        """
-
-    sign(algorithm: CryptoSigner, key: CryptoKey, data: Buffer): Buffer
-        target js async """
-            const a = internalAlgorithm_(algorithm_);
-            return new DataView(await self_.sign(a, key_, data_));
-        """
-
-    verify(algorithm: CryptoSigner, key: CryptoKey, data: Buffer): Bool
-        target js async """
-            const a = internalAlgorithm_(algorithm_);
-            return await self_.verify(a, key_, data_);
-        """
-
-    digest(algorithm: CryptoDigest, data: Buffer): Buffer
-        target js async """
-            const a = internalAlgorithm_(algorithm_);
-            return new DataView(await self_.digest(a, data_));
-        """
-        
-    deriveBits(algorithm: CryptoDeriver, key: CryptoKey, bits: Int): Buffer
-        target js async """
-            const a = internalAlgorithm_(algorithm_);
-            return new DataView(await self_.deriveBits(a, key_, bits_));
-        """
-        
-    deriveKey(
-        algorithm: CryptoDeriver
-        baseKey: CryptoKey
-        derivedKeyAlgorithm: CryptoGenerator
-        extractable: Bool
-        keyUsages: CryptoKeyUsages
-    ): CryptoKey
-        target js async """
-            const a = internalAlgorithm_(algorithm_);
-            const d = internalAlgorithm_(derivedKeyAlgorithm_);
-            const u = internalKeyUsages_(keyUsages_);
-            return await self_.deriveKey(a, baseKey_, d, extractable_, u);
-        """    
-
-}
-
-internalAlgorithm(algorithm: JsValue): JsValue
-    target js sync """
-        if(algorithm_.Sha512) return 'SHA-512';
-        if(algorithm_.Sha384) return 'SHA-384';
-        if(algorithm_.Sha256) return 'SHA-256';
-        if(algorithm_.Sha1) return 'SHA-1';
-        if(algorithm_.RsassaPkcs1V15) return 'RSASSA-PKCS1-v1_5';
-        if(algorithm_.RsaPss) return {name: 'RSA-PSS', saltLength: algorithm_.saltLength_};
-        if(algorithm_.Ecdsa) return {name: 'ECDSA', hash: internalAlgorithm_(algorithm_.hash_)};
-        if(algorithm_.Hmac) return 'HMAC';
-        if(algorithm_.Ecdh) return {name: 'ECDH', public: algorithm_.public_};
-        if(algorithm_.Hkdf) return {name: 'HKDF', hash: internalAlgorithm_(algorithm_.hash_), salt: algorithm_.salt_, info: algorithm_.info_};
-        if(algorithm_.Pbkdf2) return {name: 'PBKDF2', hash: internalAlgorithm_(algorithm_.hash_), salt: algorithm_.salt_, iterations: algorithm_.iterations_};
-        if(algorithm_.RsaOaep) return {name: "RSA-OAEP", label: algorithm_.label_.value_};
-        if(algorithm_.AesCtr) return {name: "AES-CTR", counter: algorithm_.counter_, length: algorithm_.length_};
-        if(algorithm_.AesCbc) return {name: "AES-CBC", iv: algorithm_.initializationVector_};
-        if(algorithm_.AesGcm) return {name: "AES-GCM", iv: algorithm_.initializationVector_, additionalData: algorithm_.value_, tagLength: algorithm_.tagLength_};
-        // Turns out, generateKey has different parameters - think about naming
-        if(algorithm_.HmacGenerator) return {name: 'HMAC', hash: internalAlgorithm_(algorithm_.hash_), length: algorithm_.length_.value_};
-        if(algorithm_.AesCtrGenerator) return {name: 'AES-CTR', length: algorithm_.length_};
-        if(algorithm_.AesCbcGenerator) return {name: 'AES-CBC', length: algorithm_.length_};
-        if(algorithm_.AesGcmGenerator) return {name: 'AES-GCM', length: algorithm_.length_};
-        if(algorithm_.AesKwGenerator) return {name: 'AES-KW', length: algorithm_.length_};
-        if(algorithm_.HkdfGenerator) return {name: 'HKDF', hash: internalAlgorithm_(algorithm_.hash_), salt: algorithm_.salt_, info: algorithm_.info_};
-        if(algorithm_.Pbkdf2Generator) return {name: 'PBKDF2', hash: internalAlgorithm_(algorithm_.hash_), salt: algorithm_.salt_, iterations: algorithm_.iterations_};
-        throw new Error('No such algorithm');
-    """
-
-internalKeyUsages(keyUsages: JsValue): JsValue
-    target js sync """
-        const u = [];
-        if(keyUsages_.encrypt_) u.push('encrypt');
-        if(keyUsages_.decrypt_) u.push('decrypt');
-        if(keyUsages_.sign_) u.push('sign');
-        if(keyUsages_.verify_) u.push('verify');
-        if(keyUsages_.deriveKey_) u.push('deriveKey');
-        if(keyUsages_.deriveBits_) u.push('deriveBits');
-        if(keyUsages_.wrapKey_) u.push('wrapKey');
-        if(keyUsages_.unwrapKey_) u.push('unwrapKey');
-        return u;
-    """