firefly-compiler 0.4.78 → 0.4.79

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);
     
 }
 
@@ -186,8 +186,8 @@ return (v_ === 0)
 }
 
 export async function Crypto_randomUuid$(self_, $task) {
-
-            return self_.randomUUID();
+
+            return self_.randomUUID();
         
 }
 
@@ -198,33 +198,33 @@ 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);
         
 }
 

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

@@ -121,13 +121,13 @@ return {redirect_, referrer_, integrity_, mode_, credentials_, cache_};
 
 
 export function internalCheck_(fetchResponse_) {
-
-        if(fetchResponse_.response === null) {
-            throw new Error("Response closed");
-        }
-        if(!fetchResponse_.statusChecked && !fetchResponse_.response.ok) {
-            throw new Error("Unchecked HTTP status code: " + fetchResponse_.response.status);
-        }
+
+        if(fetchResponse_.response === null) {
+            throw new Error("Response closed");
+        }
+        if(!fetchResponse_.statusChecked && !fetchResponse_.response.ok) {
+            throw new Error("Unchecked HTTP status code: " + fetchResponse_.response.status);
+        }
     
 }
 
@@ -172,28 +172,28 @@ return (await ff_core_HttpClient.HttpClient_fetch$(self_, "DELETE", url_, header
 }
 
 export async function HttpClient_fetch$(self_, method_, url_, headers_ = [], payload_ = ff_core_Option.None(), options_ = ff_core_HttpClient.FetchOptions(), body_, $task) {
-
-            const fetchResponse = {response: null, statusChecked: false};
-            try {
-                const options = {headers: {}, signal: $task.controller.signal};
-                options.method = method_;
-                headers_.forEach(pair => {options.headers[pair.first_] = pair.second_});
-                if(payload_.value_) options.body = payload_.value_;
-                if(options_.redirect_.RedirectError) options.redirect = "error";
-                else if(options_.redirect_.RedirectManual) options.redirect = "manual";
-                if(options_.referrer_.value_) options.referrer = options_.referrer_.value_;
-                if(options_.integrity_.value_) options.integrity = options_.integrity_.value_;
-                if(options_.mode_.value_) options.mode = options_.mode_.value_;
-                if(options_.credentials_.value_) options.credentials = options_.credentials_.value_;
-                if(options_.cache_.value_) options.cache = options_.cache_.value_;
-                fetchResponse.response = await self_.fetch(url_, options);
-                const result = await body_(fetchResponse, $task);
-                internalCheck_(fetchResponse);
-                return result;
-            } finally {
-                fetchResponse.response = null;
-                if($task.controller.signal.aborted) $task.controller = new AbortController()
-            }
+
+            const fetchResponse = {response: null, statusChecked: false};
+            try {
+                const options = {headers: {}, signal: $task.controller.signal};
+                options.method = method_;
+                headers_.forEach(pair => {options.headers[pair.first_] = pair.second_});
+                if(payload_.value_) options.body = payload_.value_;
+                if(options_.redirect_.RedirectError) options.redirect = "error";
+                else if(options_.redirect_.RedirectManual) options.redirect = "manual";
+                if(options_.referrer_.value_) options.referrer = options_.referrer_.value_;
+                if(options_.integrity_.value_) options.integrity = options_.integrity_.value_;
+                if(options_.mode_.value_) options.mode = options_.mode_.value_;
+                if(options_.credentials_.value_) options.credentials = options_.credentials_.value_;
+                if(options_.cache_.value_) options.cache = options_.cache_.value_;
+                fetchResponse.response = await self_.fetch(url_, options);
+                const result = await body_(fetchResponse, $task);
+                internalCheck_(fetchResponse);
+                return result;
+            } finally {
+                fetchResponse.response = null;
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
         
 }
 
@@ -226,57 +226,57 @@ throw new Error('Function FetchResponse_readBuffer is missing on this target in
 }
 
 export async function FetchResponse_ok$(self_, $task) {
-
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.ok;
+
+            self_.statusChecked = true;
+            internalCheck_(self_);
+            return self_.response.ok;
         
 }
 
 export async function FetchResponse_status$(self_, $task) {
-
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.status;
+
+            self_.statusChecked = true;
+            internalCheck_(self_);
+            return self_.response.status;
         
 }
 
 export async function FetchResponse_statusText$(self_, $task) {
-
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.statusText;
+
+            self_.statusChecked = true;
+            internalCheck_(self_);
+            return self_.response.statusText;
         
 }
 
 export async function FetchResponse_header$(self_, name_, $task) {
-
-            internalCheck_(self_);
-            const header = self_.response.headers.get(name_);
-            return header != null
-                ? ff_core_Option.Some(header)
-                : ff_core_Option.None();
+
+            internalCheck_(self_);
+            const header = self_.response.headers.get(name_);
+            return header != null
+                ? ff_core_Option.Some(header)
+                : ff_core_Option.None();
         
 }
 
 export async function FetchResponse_readText$(self_, $task) {
-
-            internalCheck_(self_);
-            return await self_.response.text();
+
+            internalCheck_(self_);
+            return await self_.response.text();
         
 }
 
 export async function FetchResponse_readJson$(self_, $task) {
-
-            internalCheck_(self_);
-            return await self_.response.json();
+
+            internalCheck_(self_);
+            return await self_.response.json();
         
 }
 
 export async function FetchResponse_readBuffer$(self_, $task) {
-
-            internalCheck_(self_);
-            return new DataView(await self_.response.arrayBuffer());
+
+            internalCheck_(self_);
+            return new DataView(await self_.response.arrayBuffer());
         
 }