firefly-compiler 0.4.36 → 0.4.46

package/core/Box.ff

@@ -1,7 +1,7 @@
-class Box[T](mutable value: T)
-
-extend self[T]: Box[T] {
-    modify(body: T => T): Unit {
-        self.value = body(self.value)
-    }
-}
+class Box[T](mutable value: T)
+
+extend self[T]: Box[T] {
+    modify(body: T => T): Unit {
+        self.value = body(self.value)
+    }
+}

package/core/BrowserSystem.ff

@@ -1,37 +1,40 @@
-capability BrowserSystem {}
-
-extend self: BrowserSystem {
-
-    httpClient(): HttpClient
-        target js async "return null"
-    
-    mainTask(): Task
-        target js async "return self_.task_"
-
-    js(): JsSystem
-        target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
-        
-    url(): String
-        target js async """
-            return location.href;
-        """
-    
-    urlPath(): String
-        target js async """
-            return location.pathname;
-        """
-
-    urlQuery(name: String): Option[String]
-        target js async """
-            const param = new URLSearchParams(location.search).get(name_)
-            if(param == null) return ff_core_Option.None();
-            return ff_core_Option.Some(param);
-        """
-
-    urlFragment(): Option[String]
-        target js async """
-            if(!location.hash.startsWith('#')) return ff_core_Option.None();
-            return ff_core_Option.Some(location.hash.slice(1));
-        """
-               
-}
+capability BrowserSystem {}
+
+extend self: BrowserSystem {
+
+    httpClient(): HttpClient
+        target js async "return null"
+    
+    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"
+        
+    url(): String
+        target js async """
+            return location.href;
+        """
+    
+    urlPath(): String
+        target js async """
+            return location.pathname;
+        """
+
+    urlQuery(name: String): Option[String]
+        target js async """
+            const param = new URLSearchParams(location.search).get(name_)
+            if(param == null) return ff_core_Option.None();
+            return ff_core_Option.Some(param);
+        """
+
+    urlFragment(): Option[String]
+        target js async """
+            if(!location.hash.startsWith('#')) return ff_core_Option.None();
+            return ff_core_Option.Some(location.hash.slice(1));
+        """
+               
+}

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

@@ -1,145 +1,148 @@
-capability BuildSystem {}
-capability BrowserCode(packageGroup: String, packageName: String, mainFile: Path, assetSystem: AssetSystem)
-capability BrowserBundle(assetSystem: AssetSystem)
-
-extend self: BuildSystem {
-
-    compileForBrowser(mainFile: String): BrowserCode {
-        // TODO: Check that the mainFile is in the current package directory
-        internalCompile(self, internalPath(self, mainFile), "browser")
-        let streams = internalListDirectory(internalPath(self, ".firefly/output/browser"))
-        let mainPackagePair = internalMainPackagePair(self)
-        BrowserCode(
-            packageGroup = mainPackagePair.first
-            packageName = mainPackagePair.second
-            mainFile = internalPath(self, mainFile)
-            assetSystem = AssetSystem(streams.toMap())
-        )
-    }
-
-    buildMode(): Bool
-        target node async "return !!self_.buildMode_"
-
-    setAssets(assetSystem: AssetSystem): Unit
-        target node async "self_.assets_ = assetSystem_"
-
-    packageAssets(): AssetSystem {
-        let streams = internalListDirectory(internalPath(self, "."))
-        AssetSystem(streams.toMap())
-    }
-
-    dependencyAssets(user: String, package: String): AssetSystem {
-        panic("dependencyAssets not yet implemented")
-    }
-
-    arguments(): List[String]
-        target node async "return self_.array_"
-
-    mainTask(): Task
-        target js async "return self_.task_"
-
-}
-
-extend self: BrowserCode {
-
-    assets(): AssetSystem {
-        self.assetSystem
-    }
-
-    bundle(minify: Bool = True, sourceMap: Bool = False): BrowserBundle {
-        let prefix = ".firefly/output/browser"
-        let mainJsBaseFile = self.mainFile.base().removeLast(".ff").grab() + ".mjs"
-        let mainJsFile = prefix + "/" + self.packageGroup + "/" + self.packageName + "/" + mainJsBaseFile
-        let mainDirectory = self.mainFile.parent().grab()
-        let file = prefix + "/Main.bundle.js"
-        internalCallEsBuild(self, mainJsFile = mainJsFile, outputPath = file, minify = minify, sourceMap = sourceMap)
-        let assets = AssetSystem([
-            Pair(file.dropFirst(prefix.size()), {mainDirectory.path(file).readStream()})
-            ...if(sourceMap) {[
-                Pair(file.dropFirst(prefix.size()) + ".map", {mainDirectory.path(file + ".map").readStream()})
-            ]} else {[]}
-        ].toMap())
-        BrowserBundle(assets)
-    }
-
-}
-
-extend self: BrowserBundle {
-
-    assets(): AssetSystem {
-        self.assetSystem
-    }
-
-}
-
-
-internalCallEsBuild(
-    self: BrowserCode
-    mainJsFile: String
-    outputPath: String
-    minify: Bool
-    sourceMap: Bool
-): Unit
-    target node async """
-        import * as esbuild from 'esbuild'
-        return await esbuild.build({
-            entryPoints: [mainJsFile_],
-            bundle: true,
-            minify: minify_,
-            sourcemap: sourceMap_,
-            platform: 'browser',
-            target: 'es6',
-            external: ['../../../node_modules/*'], // TODO
-            outfile: outputPath_
-        })
-    """
-
-internalNodeCallEsBuild(
-    self: NodeSystem
-    mainJsFile: String
-    outputPath: String
-    minify: Bool
-): Unit
-    target node async """
-        import * as esbuild from 'esbuild'
-        return await esbuild.build({
-            entryPoints: [mainJsFile_],
-            bundle: true,
-            minify: minify_,
-            sourcemap: true,
-            platform: 'node',
-            target: 'es6',
-            external: ['../../../node_modules/*'], // TODO
-            outfile: outputPath_
-        })
-    """
-
-internalListDirectory(path: Path): List[Pair[String, () => Stream[Buffer]]] {
-    function go(currentPath: Path): Stream[Path] {
-        currentPath.entries().flatMap {file =>
-            if(file.isDirectory()) {
-                go(file.path())
-            } else {
-                [file.path()].toStream()
-            }
-        }
-    }
-    go(path).map {file =>
-        Pair("/" + file.relativeTo(path).replace("\\", "/"), {file.readStream()})
-    }.toList()
-}
-
-internalPath(buildSystem: BuildSystem, absoluteOrRelative: String): Path
-    target node async """
-        return absoluteOrRelative_
-    """
-
-internalCompile(buildSystem: BuildSystem, mainFile: Path, target: String): Unit
-    target node async """
-        return await $firefly_compiler.buildViaBuildSystem_$(buildSystem_, buildSystem_.fireflyPath_, mainFile_, target_, $task)
-    """
-
-internalMainPackagePair(buildSystem: BuildSystem): Pair[String, String]
-    target node async """
-        return {first_: buildSystem_.mainPackagePair_.group_, second_: buildSystem_.mainPackagePair_.name_}
-    """
+capability BuildSystem {}
+capability BrowserCode(packageGroup: String, packageName: String, mainFile: Path, assetSystem: AssetSystem)
+capability BrowserBundle(assetSystem: AssetSystem)
+
+extend self: BuildSystem {
+
+    compileForBrowser(mainFile: String): BrowserCode {
+        // TODO: Check that the mainFile is in the current package directory
+        internalCompile(self, internalPath(self, mainFile), "browser")
+        let streams = internalListDirectory(internalPath(self, ".firefly/output/browser"))
+        let mainPackagePair = internalMainPackagePair(self)
+        BrowserCode(
+            packageGroup = mainPackagePair.first
+            packageName = mainPackagePair.second
+            mainFile = internalPath(self, mainFile)
+            assetSystem = AssetSystem(streams.toMap())
+        )
+    }
+
+    buildMode(): Bool
+        target node async "return !!self_.buildMode_"
+
+    setAssets(assetSystem: AssetSystem): Unit
+        target node async "self_.assets_ = assetSystem_"
+
+    packageAssets(): AssetSystem {
+        let streams = internalListDirectory(internalPath(self, "."))
+        AssetSystem(streams.toMap())
+    }
+
+    dependencyAssets(user: String, package: String): AssetSystem {
+        panic("dependencyAssets not yet implemented")
+    }
+
+    arguments(): List[String]
+        target node async "return self_.array_"
+
+    mainTask(): Task
+        target js async "return self_.task_"
+
+    crypto(): Crypto
+        target js async "return (typeof globalThis !== 'undefined' ? globalThis : window).crypto"
+        
+}
+
+extend self: BrowserCode {
+
+    assets(): AssetSystem {
+        self.assetSystem
+    }
+
+    bundle(minify: Bool = True, sourceMap: Bool = False): BrowserBundle {
+        let prefix = ".firefly/output/browser"
+        let mainJsBaseFile = self.mainFile.base().removeLast(".ff").grab() + ".mjs"
+        let mainJsFile = prefix + "/" + self.packageGroup + "/" + self.packageName + "/" + mainJsBaseFile
+        let mainDirectory = self.mainFile.parent().grab()
+        let file = prefix + "/Main.bundle.js"
+        internalCallEsBuild(self, mainJsFile = mainJsFile, outputPath = file, minify = minify, sourceMap = sourceMap)
+        let assets = AssetSystem([
+            Pair(file.dropFirst(prefix.size()), {mainDirectory.path(file).readStream()})
+            ...if(sourceMap) {[
+                Pair(file.dropFirst(prefix.size()) + ".map", {mainDirectory.path(file + ".map").readStream()})
+            ]} else {[]}
+        ].toMap())
+        BrowserBundle(assets)
+    }
+
+}
+
+extend self: BrowserBundle {
+
+    assets(): AssetSystem {
+        self.assetSystem
+    }
+
+}
+
+
+internalCallEsBuild(
+    self: BrowserCode
+    mainJsFile: String
+    outputPath: String
+    minify: Bool
+    sourceMap: Bool
+): Unit
+    target node async """
+        import * as esbuild from 'esbuild'
+        return await esbuild.build({
+            entryPoints: [mainJsFile_],
+            bundle: true,
+            minify: minify_,
+            sourcemap: sourceMap_,
+            platform: 'browser',
+            target: 'es6',
+            external: ['../../../node_modules/*'], // TODO
+            outfile: outputPath_
+        })
+    """
+
+internalNodeCallEsBuild(
+    self: NodeSystem
+    mainJsFile: String
+    outputPath: String
+    minify: Bool
+): Unit
+    target node async """
+        import * as esbuild from 'esbuild'
+        return await esbuild.build({
+            entryPoints: [mainJsFile_],
+            bundle: true,
+            minify: minify_,
+            sourcemap: true,
+            platform: 'node',
+            target: 'es6',
+            external: ['../../../node_modules/*'], // TODO
+            outfile: outputPath_
+        })
+    """
+
+internalListDirectory(path: Path): List[Pair[String, () => Stream[Buffer]]] {
+    function go(currentPath: Path): Stream[Path] {
+        currentPath.entries().flatMap {file =>
+            if(file.isDirectory()) {
+                go(file.path())
+            } else {
+                [file.path()].toStream()
+            }
+        }
+    }
+    go(path).map {file =>
+        Pair("/" + file.relativeTo(path).replace("\\", "/"), {file.readStream()})
+    }.toList()
+}
+
+internalPath(buildSystem: BuildSystem, absoluteOrRelative: String): Path
+    target node async """
+        return absoluteOrRelative_
+    """
+
+internalCompile(buildSystem: BuildSystem, mainFile: Path, target: String): Unit
+    target node async """
+        return await $firefly_compiler.buildViaBuildSystem_$(buildSystem_, buildSystem_.fireflyPath_, mainFile_, target_, $task)
+    """
+
+internalMainPackagePair(buildSystem: BuildSystem): Pair[String, String]
+    target node async """
+        return {first_: buildSystem_.mainPackagePair_.group_, second_: buildSystem_.mainPackagePair_.name_}
+    """

package/core/Crypto.ff

@@ -1,95 +1,96 @@
-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);
-        """
-
-    makePasswordHash(password: String, iterations: Int = 100000): String {
-        let salt = self.randomBuffer(16)
-        let hash = internalMakePasswordHash(salt, password.toBuffer(), iterations)
-        "PSG_" + 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)
-                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 == 0
-    }
-
-}
-
-internalMakePasswordHash(salt: Buffer, password: Buffer, iterations: Int): Buffer
-    target js async """
-        const keyMaterial = await crypto.subtle.importKey(
-            'raw',
-            password_,
-            {name: 'PBKDF2'},
-            false,
-            ['deriveKey']
-        );
-        const derivedKey = await crypto.subtle.deriveKey(
-            {
-                name: 'PBKDF2',
-                salt: salt_,
-                iterations: iterations_,
-                hash: 'SHA-256'
-            },
-            keyMaterial,
-            {name: 'AES-GCM', length: 256},
-            true,
-            ['encrypt', 'decrypt']
-        );
-        const hashBuffer = await crypto.subtle.exportKey('raw', derivedKey);
-        return new DataView(hashBuffer);
-    """
+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);
+    """