firefly-compiler 0.4.40 → 0.4.48

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

@@ -96,8 +96,8 @@ import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
 
 export function new_(value_) {
-
-        return {value: value_}
+
+        return {value: value_}
     
 }
 
@@ -106,68 +106,68 @@ throw new Error('Function new is missing on this target in async context.');
 }
 
 export function Atomic_modify(self_, body_) {
-
-            return self_.value = body_(self_.value)
+
+            return self_.value = body_(self_.value)
         
 }
 
 export function Atomic_getAndModify(self_, body_) {
-
-            const currentValue = self_.value
-            self_.value = body_(currentValue)
-            return currentValue
+
+            const currentValue = self_.value
+            self_.value = body_(currentValue)
+            return currentValue
         
 }
 
 export function Atomic_get(self_) {
-
-            return self_.value
+
+            return self_.value
         
 }
 
 export function Atomic_set(self_, value_) {
-
-            self_.value = value
+
+            self_.value = value
         
 }
 
 export function Atomic_getAndSet(self_, newValue_) {
-
-            const currentValue = self_.value
-            self_.value = newValue
-            return currentValue
+
+            const currentValue = self_.value
+            self_.value = newValue
+            return currentValue
         
 }
 
 export function Atomic_compareAndSet(self_, currentValue_, newValue_) {
-
-            if(self_.value !== currentValue) return false
-            self_.value = newValue
-            return true
+
+            if(self_.value !== currentValue) return false
+            self_.value = newValue
+            return true
         
 }
 
 export async function Atomic_modify$(self_, body_, $task) {
-
-            let currentValue, newValue
-            do {
-                currentValue = self_.value
-                newValue = await body_(currentValue)
-            } while(currentValue !== self_.value)
-            self_.value = newValue
-            return newValue
+
+            let currentValue, newValue
+            do {
+                currentValue = self_.value
+                newValue = await body_(currentValue)
+            } while(currentValue !== self_.value)
+            self_.value = newValue
+            return newValue
         
 }
 
 export async function Atomic_getAndModify$(self_, body_, $task) {
-
-            let currentValue, newValue
-            do {
-                currentValue = self_.value
-                newValue = await body_(currentValue)
-            } while(currentValue !== self_.value)
-            self_.value = newValue
-            return currentValue
+
+            let currentValue, newValue
+            do {
+                currentValue = self_.value
+                newValue = await body_(currentValue)
+            } while(currentValue !== self_.value)
+            self_.value = newValue
+            return currentValue
         
 }
 

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

@@ -148,29 +148,29 @@ return typeof globalThis !== 'undefined' ? globalThis : window
 }
 
 export async function BrowserSystem_url$(self_, $task) {
-
-            return location.href;
+
+            return location.href;
         
 }
 
 export async function BrowserSystem_urlPath$(self_, $task) {
-
-            return location.pathname;
+
+            return location.pathname;
         
 }
 
 export async function BrowserSystem_urlQuery$(self_, name_, $task) {
-
-            const param = new URLSearchParams(location.search).get(name_)
-            if(param == null) return ff_core_Option.None();
-            return ff_core_Option.Some(param);
+
+            const param = new URLSearchParams(location.search).get(name_)
+            if(param == null) return ff_core_Option.None();
+            return ff_core_Option.Some(param);
         
 }
 
 export async function BrowserSystem_urlFragment$(self_, $task) {
-
-            if(!location.hash.startsWith('#')) return ff_core_Option.None();
-            return ff_core_Option.Some(location.hash.slice(1));
+
+            if(!location.hash.startsWith('#')) return ff_core_Option.None();
+            return ff_core_Option.Some(location.hash.slice(1));
         
 }
 

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

@@ -143,34 +143,34 @@ throw new Error('Function internalMainPackagePair is missing on this target in s
 }
 
 export async function internalCallEsBuild_$(self_, mainJsFile_, outputPath_, minify_, sourceMap_, $task) {
-
-        const esbuild = import$0
-        return await esbuild.build({
-            entryPoints: [mainJsFile_],
-            bundle: true,
-            minify: minify_,
-            sourcemap: sourceMap_,
-            platform: 'browser',
-            target: 'es6',
-            external: ['../../../node_modules/*'], // TODO
-            outfile: outputPath_
-        })
+
+        const esbuild = import$0
+        return await esbuild.build({
+            entryPoints: [mainJsFile_],
+            bundle: true,
+            minify: minify_,
+            sourcemap: sourceMap_,
+            platform: 'browser',
+            target: 'es6',
+            external: ['../../../node_modules/*'], // TODO
+            outfile: outputPath_
+        })
     
 }
 
 export async function internalNodeCallEsBuild_$(self_, mainJsFile_, outputPath_, minify_, $task) {
-
-        const esbuild = import$0
-        return await esbuild.build({
-            entryPoints: [mainJsFile_],
-            bundle: true,
-            minify: minify_,
-            sourcemap: true,
-            platform: 'node',
-            target: 'es6',
-            external: ['../../../node_modules/*'], // TODO
-            outfile: outputPath_
-        })
+
+        const esbuild = import$0
+        return await esbuild.build({
+            entryPoints: [mainJsFile_],
+            bundle: true,
+            minify: minify_,
+            sourcemap: true,
+            platform: 'node',
+            target: 'es6',
+            external: ['../../../node_modules/*'], // TODO
+            outfile: outputPath_
+        })
     
 }
 
@@ -192,20 +192,20 @@ return (await ff_core_Path.Path_readStream$(file_, $task))
 }
 
 export async function internalPath_$(buildSystem_, absoluteOrRelative_, $task) {
-
-        return absoluteOrRelative_
+
+        return absoluteOrRelative_
     
 }
 
 export async function internalCompile_$(buildSystem_, mainFile_, target_, $task) {
-
-        return await $firefly_compiler.buildViaBuildSystem_$(buildSystem_, buildSystem_.fireflyPath_, mainFile_, target_, $task)
+
+        return await $firefly_compiler.buildViaBuildSystem_$(buildSystem_, buildSystem_.fireflyPath_, mainFile_, target_, $task)
     
 }
 
 export async function internalMainPackagePair_$(buildSystem_, $task) {
-
-        return {first_: buildSystem_.mainPackagePair_.group_, second_: buildSystem_.mainPackagePair_.name_}
+
+        return {first_: buildSystem_.mainPackagePair_.group_, second_: buildSystem_.mainPackagePair_.name_}
     
 }
 

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

@@ -100,25 +100,25 @@ throw new Error('Function internalHashPassword is missing on this target in sync
 }
 
 export async function internalHashPassword_$(system_, salt_, password_, iterations_, $task) {
-
-        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);
+
+        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);
     
 }
 
@@ -144,29 +144,27 @@ export function Crypto_sha256(self_, buffer_) {
 throw new Error('Function Crypto_sha256 is missing on this target in sync context.');
 }
 
-export function Crypto_hashPassword(self_, password_, iterations_ = 600000, pepper_ = "") {
+export function Crypto_hashPassword(self_, password_, iterations_ = 600000) {
 const salt_ = ff_core_Crypto.Crypto_randomBuffer(self_, 16);
-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_))
+const hash_ = ff_core_Crypto.internalHashPassword_(self_, salt_, ff_core_String.String_toBuffer(password_), iterations_);
+return ((((("$pbkdf2-sha256-hex$" + iterations_) + "$") + ff_core_Buffer.Buffer_toHex(salt_)) + "$") + ff_core_Buffer.Buffer_toHex(hash_))
 }
 
-export function Crypto_checkPassword(self_, password_, passwordHash_, pepper_ = "", minIterations_ = 100000, maxIterations_ = 2000000) {
+export function Crypto_checkPassword(self_, password_, passwordHash_) {
 {
 const _1 = ff_core_String.String_split(passwordHash_, 36);
-if(_1.length === 5 && _1[0] === "" && _1[1] === "pbkdf2-sha256") {
+if(_1.length === 5 && _1[0] === "" && _1[1] === "pbkdf2-sha256-hex") {
 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 _guard1 = ff_core_String.String_getInt(iterationsText_);
+if(_guard1.Some) {
+const iterations_ = _guard1.value_;
+const computedHash_ = ff_core_Crypto.internalHashPassword_(self_, ff_core_Buffer.fromHex_(saltText_), ff_core_String.String_toBuffer(password_), iterations_);
 const hash_ = ff_core_Buffer.fromHex_(hashText_);
 return ff_core_Crypto.Crypto_constantTimeEquals(self_, computedHash_, hash_)
 }
 }
-}
 {
 return false
 }
@@ -188,8 +186,8 @@ return (v_ === 0)
 }
 
 export async function Crypto_randomUuid$(self_, $task) {
-
-            return self_.randomUUID();
+
+            return self_.randomUUID();
         
 }
 
@@ -200,59 +198,57 @@ return buffer_
 }
 
 export async function Crypto_randomizeBuffer$(self_, buffer_, $task) {
-
-            self_.getRandomValues(new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength));
+
+            self_.getRandomValues(new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength));
         
 }
 
 export async function Crypto_hmacSha256$(self_, key_, buffer_, $task) {
-
-            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);
+
+            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);
         
 }
 
 export async function Crypto_sha256$(self_, buffer_, $task) {
-
-            let hash = await self_.subtle.digest('SHA-256', buffer_);
-            return new DataView(hash);
+
+            let hash = await self_.subtle.digest('SHA-256', buffer_);
+            return new DataView(hash);
         
 }
 
-export async function Crypto_hashPassword$(self_, password_, iterations_ = 600000, pepper_ = "", $task) {
+export async function Crypto_hashPassword$(self_, password_, iterations_ = 600000, $task) {
 const salt_ = (await ff_core_Crypto.Crypto_randomBuffer$(self_, 16, $task));
-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_))
+const hash_ = (await ff_core_Crypto.internalHashPassword_$(self_, salt_, ff_core_String.String_toBuffer(password_), iterations_, $task));
+return ((((("$pbkdf2-sha256-hex$" + iterations_) + "$") + ff_core_Buffer.Buffer_toHex(salt_)) + "$") + ff_core_Buffer.Buffer_toHex(hash_))
 }
 
-export async function Crypto_checkPassword$(self_, password_, passwordHash_, pepper_ = "", minIterations_ = 100000, maxIterations_ = 2000000, $task) {
+export async function Crypto_checkPassword$(self_, password_, passwordHash_, $task) {
 {
 const _1 = ff_core_String.String_split(passwordHash_, 36);
-if(_1.length === 5 && _1[0] === "" && _1[1] === "pbkdf2-sha256") {
+if(_1.length === 5 && _1[0] === "" && _1[1] === "pbkdf2-sha256-hex") {
 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 _guard1 = ff_core_String.String_getInt(iterationsText_);
+if(_guard1.Some) {
+const iterations_ = _guard1.value_;
+const computedHash_ = (await ff_core_Crypto.internalHashPassword_$(self_, ff_core_Buffer.fromHex_(saltText_), ff_core_String.String_toBuffer(password_), iterations_, $task));
 const hash_ = ff_core_Buffer.fromHex_(hashText_);
 return (await ff_core_Crypto.Crypto_constantTimeEquals$(self_, computedHash_, hash_, $task))
 }
 }
-}
 {
 return false
 }

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

@@ -136,25 +136,25 @@ throw new Error('Function HttpClient_fetch is missing on this target in sync con
 }
 
 export async function HttpClient_fetch$(self_, url_, method_ = "GET", headers_ = ff_core_HttpClient.emptyList_, body_ = ff_core_Option.None(), redirect_ = ff_core_HttpClient.RedirectFollow(), referrer_ = ff_core_Option.None(), integrity_ = ff_core_Option.None(), mode_ = ff_core_Option.None(), credentials_ = ff_core_Option.None(), cache_ = ff_core_Option.None(), throw_ = true, $task) {
-
-            try {
-                const options = {headers: {}, signal: $task.controller.signal}
-                options.method = method_
-                headers_.forEach(pair => {options.headers[pair.first_] = pair.second_})
-                if(body_.value_) options.body = body_.value_
-                if(redirect_.RedirectError) options.redirect = "error"
-                else if(redirect_.RedirectManual) options.redirect = "manual"
-                if(referrer_.value_) options.referrer = referrer_.value_
-                if(integrity_.value_) options.integrity = integrity_.value_
-                if(mode_.value_) options.mode = mode_.value_
-                if(credentials_.value_) options.credentials = credentials_.value_
-                if(cache_.value_) options.cache = cache_.value_
-                let result = await fetch(url_, options)
-                if(throw_ && !result.ok) throw new Error("Unexpected HTTP status code: " + result.status)
-                return result
-            } finally {
-                if($task.controller.signal.aborted) $task.controller = new AbortController()
-            }
+
+            try {
+                const options = {headers: {}, signal: $task.controller.signal}
+                options.method = method_
+                headers_.forEach(pair => {options.headers[pair.first_] = pair.second_})
+                if(body_.value_) options.body = body_.value_
+                if(redirect_.RedirectError) options.redirect = "error"
+                else if(redirect_.RedirectManual) options.redirect = "manual"
+                if(referrer_.value_) options.referrer = referrer_.value_
+                if(integrity_.value_) options.integrity = integrity_.value_
+                if(mode_.value_) options.mode = mode_.value_
+                if(credentials_.value_) options.credentials = credentials_.value_
+                if(cache_.value_) options.cache = cache_.value_
+                let result = await fetch(url_, options)
+                if(throw_ && !result.ok) throw new Error("Unexpected HTTP status code: " + result.status)
+                return result
+            } finally {
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
         
 }
 
@@ -199,11 +199,11 @@ return self_.statusText
 }
 
 export async function FetchResponse_header$(self_, name_, $task) {
-
-            const header = self_.headers.get(name_)
-            return header != null
-                ? ff_core_Option.Some(header)
-                : ff_core_Option.None()
+
+            const header = self_.headers.get(name_)
+            return header != null
+                ? ff_core_Option.Some(header)
+                : ff_core_Option.None()
         
 }