firefly-compiler 0.4.36 → 0.4.46

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

@@ -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,34 +139,38 @@ 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
 }
 
 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/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

@@ -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_}
     
 }
 
@@ -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,33 +95,30 @@ 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) {
-
-        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);
+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);
     
 }
 
@@ -147,23 +144,23 @@ 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) {
 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_), iterations_);
+return ((((("$pbkdf2-sha256-hex$" + 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_) {
 {
-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 _1 = ff_core_String.String_split(passwordHash_, 36);
+if(_1.length === 5 && _1[0] === "" && _1[1] === "pbkdf2-sha256-hex") {
+const iterationsText_ = _1[2];
+const saltText_ = _1[3];
+const hashText_ = _1[4];
 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 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_)
 }
@@ -181,15 +178,16 @@ 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)
 }
 }
 
 export async function Crypto_randomUuid$(self_, $task) {
-
-            return self_.randomUUID();
+
+            return self_.randomUUID();
         
 }
 
@@ -200,53 +198,53 @@ 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_makePasswordHash$(self_, password_, iterations_ = 100000, $task) {
+export async function Crypto_hashPassword$(self_, password_, iterations_ = 600000, $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_), iterations_, $task));
+return ((((("$pbkdf2-sha256-hex$" + 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_, $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 _1 = ff_core_String.String_split(passwordHash_, 36);
+if(_1.length === 5 && _1[0] === "" && _1[1] === "pbkdf2-sha256-hex") {
+const iterationsText_ = _1[2];
+const saltText_ = _1[3];
+const hashText_ = _1[4];
 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 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))
 }
@@ -264,7 +262,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/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()
         
 }
 

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.');
+}
+