firefly-compiler 0.5.35 → 0.5.37

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

@@ -48,6 +48,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -74,6 +76,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -96,10 +100,10 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // type Path
-
+export function Path(absolutePath_) {
+return {absolutePath_};
+}
 
 // type PathEntry
 
@@ -107,57 +111,252 @@ import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
 
 
 export function internalReadStream_(createReadStream_) {
-throw new Error('Function internalReadStream is missing on this target in sync context.');
+let readable_ = ff_core_Option.None();
+let seenError_ = null;
+const emptyResolve_ = (() => {
+
+});
+const emptyReject_ = ((_) => {
+
+});
+let doResolve_ = emptyResolve_;
+let doReject_ = emptyReject_;
+const open_ = (() => {
+const newReadable_ = createReadStream_();
+newReadable_.on("readable", (() => {
+return doResolve_()
+}));
+newReadable_.on("error", ((error_) => {
+seenError_ = error_;
+return doReject_(error_)
+}));
+newReadable_.on("close", (() => {
+return doResolve_()
+}));
+readable_ = ff_core_Option.Some(newReadable_);
+return newReadable_
+});
+return ff_core_Stream.Stream((() => {
+;
+const jsStream_ = ff_core_Option.Option_else(readable_, open_);
+function go_() {
+_tailcall: for(;;) {
+const jsBuffer_ = jsStream_.read();
+if((!ff_core_JsValue.JsValue_isNullOrUndefined(jsBuffer_))) {
+const buffer_ = (new DataView(jsBuffer_.buffer, jsBuffer_.byteOffset, jsBuffer_.length));
+return ff_core_Option.Some(buffer_)
+} else {
+if((!ff_core_JsValue.JsValue_isNullOrUndefined(seenError_))) {
+return ff_core_Core.throwAny_(seenError_)
+} else {
+if(jsStream_.destroyed) {
+return ff_core_Option.None()
+} else {
+ff_core_Js.withSignal_(((signal_) => {
+const promise_ = (new Promise(((resolve_, reject_) => {
+const jsDoReject_ = ((_w1) => {
+return doReject_(_w1)
+});
+doResolve_ = (() => {
+signal_.removeEventListener("abort", jsDoReject_);
+doResolve_ = emptyResolve_;
+doReject_ = emptyReject_;
+resolve_()
+});
+doReject_ = ((error_) => {
+signal_.removeEventListener("abort", jsDoReject_);
+doResolve_ = emptyResolve_;
+doReject_ = emptyReject_;
+reject_(error_)
+});
+return signal_.addEventListener("abort", jsDoReject_)
+})));
+return promise_
+}));
+{
+
+
+continue _tailcall
+}
+}
+}
+}
+return
+}
+}
+return go_()
+}), (() => {
+{
+const if_o = readable_
+if(if_o.Some) {
+const _w1 = if_o.value_;
+_w1.destroy()
+}
+}
+}))
+}
+
+export function internalWriteStream_(path_, stream_, flags_) {
+const fs_ = import$0;
+const writable_ = fs_.createWriteStream(path_.absolutePath_, {flags: flags_});
+try {
+ff_core_Stream.Stream_each(stream_, ((buffer_) => {
+if((!writable_.write((new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength))))) {
+ff_core_Js.withSignal_(((signal_) => {
+return (new Promise(((resolve_, reject_) => {
+signal_.addEventListener("abort", reject_);
+return writable_.once("drain", (() => {
+signal_.removeEventListener("abort", reject_);
+return resolve_()
+}))
+})))
+}))
+}
+}))
+} finally {
+(new Promise(((resolve_, reject_) => {
+return writable_.close(((err_) => {
+if(err_) {
+return reject_(err_)
+} else {
+return resolve_()
+}
+}))
+})))
+}
 }
 
 export async function internalReadStream_$(createReadStream_, $task) {
-
-        let task = null
-        let readable = null
-        let doResolve = null
-        let doReject = null
-        let seenError = null
-        const abort = () => {
-            if(task != null) {
-                task.controller.signal.removeEventListener('abort', abort)
-                readable.destroy()
-            }
-        }
-        function open($task) {
-            ff_core_Task.Task_throwIfAborted($task)
-            task = $task
-            readable = createReadStream_()
-            readable.on('readable', () => {
-                if(doResolve != null) doResolve()
-            })
-            readable.on('error', error => {
-                task.controller.signal.removeEventListener('abort', abort)
-                seenError = error
-                if(doReject != null) doReject(error)
-            })
-            readable.on('close', () => {
-                task.controller.signal.removeEventListener('abort', abort)
-                if(doResolve != null) doResolve()
-            })
-            $task.controller.signal.addEventListener('abort', abort)
-        }
-        return ff_core_Stream.Stream(async function go($task) {
-            if(task == null) open($task)
-            let buffer = readable.read()
-            if(buffer != null) return ff_core_Option.Some(new DataView(buffer.buffer, buffer.byteOffset, buffer.length))
-            if(seenError != null) throw seenError
-            if(readable.destroyed) return ff_core_Option.None()
-            let promise = new Promise((resolve, reject) => {
-                doResolve = () => {doResolve = null; doReject = null; resolve()}
-                doReject = error => {doResolve = null; doReject = null; reject(error)}
-            }).then(() => go($task))
-            return await promise
-        }, abort)
-    
+let readable_ = ff_core_Option.None();
+let seenError_ = null;
+const emptyResolve_ = (() => {
+
+});
+const emptyReject_ = ((_) => {
+
+});
+let doResolve_ = emptyResolve_;
+let doReject_ = emptyReject_;
+const open_ = (async ($task) => {
+const newReadable_ = (await createReadStream_($task));
+newReadable_.on("readable", (() => {
+return doResolve_()
+}));
+newReadable_.on("error", ((error_) => {
+seenError_ = error_;
+return doReject_(error_)
+}));
+newReadable_.on("close", (() => {
+return doResolve_()
+}));
+readable_ = ff_core_Option.Some(newReadable_);
+return newReadable_
+});
+return ff_core_Stream.Stream((async ($task) => {
+ff_core_Task.Task_throwIfAborted($task);
+const jsStream_ = (await ff_core_Option.Option_else$(readable_, open_, $task));
+async function go_$($task) {
+_tailcall: for(;;) {
+const jsBuffer_ = jsStream_.read();
+if((!ff_core_JsValue.JsValue_isNullOrUndefined(jsBuffer_))) {
+const buffer_ = (new DataView(jsBuffer_.buffer, jsBuffer_.byteOffset, jsBuffer_.length));
+return ff_core_Option.Some(buffer_)
+} else {
+if((!ff_core_JsValue.JsValue_isNullOrUndefined(seenError_))) {
+return ff_core_Core.throwAny_(seenError_)
+} else {
+if(jsStream_.destroyed) {
+return ff_core_Option.None()
+} else {
+(await ff_core_Js.withSignal_$((async (signal_, $task) => {
+const promise_ = (new Promise(((resolve_, reject_) => {
+const jsDoReject_ = ((_w1) => {
+return doReject_(_w1)
+});
+doResolve_ = (() => {
+signal_.removeEventListener("abort", jsDoReject_);
+doResolve_ = emptyResolve_;
+doReject_ = emptyReject_;
+resolve_()
+});
+doReject_ = ((error_) => {
+signal_.removeEventListener("abort", jsDoReject_);
+doResolve_ = emptyResolve_;
+doReject_ = emptyReject_;
+reject_(error_)
+});
+return signal_.addEventListener("abort", jsDoReject_)
+})));
+return (await promise_)
+}), $task));
+{
+
+
+continue _tailcall
+}
+}
+}
+}
+return
+}
+}
+return (await go_$($task))
+}), (async ($task) => {
+{
+const if_o = readable_
+if(if_o.Some) {
+const _w1 = if_o.value_;
+_w1.destroy()
+}
+}
+}))
+}
+
+export async function internalWriteStream_$(path_, stream_, flags_, $task) {
+const fs_ = import$0;
+const writable_ = fs_.createWriteStream(path_.absolutePath_, {flags: flags_});
+try {
+(await ff_core_Stream.Stream_each$(stream_, (async (buffer_, $task) => {
+if((!writable_.write((new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength))))) {
+(await ff_core_Js.withSignal_$((async (signal_, $task) => {
+return (await (new Promise(((resolve_, reject_) => {
+signal_.addEventListener("abort", reject_);
+return writable_.once("drain", (() => {
+signal_.removeEventListener("abort", reject_);
+return resolve_()
+}))
+}))))
+}), $task))
+}
+}), $task))
+} finally {
+(await (new Promise(((resolve_, reject_) => {
+return writable_.close(((err_) => {
+if(err_) {
+return reject_(err_)
+} else {
+return resolve_()
+}
+}))
+}))))
+}
 }
 
 export function Path_exists(self_, checkReadable_ = false, checkWritable_ = false, checkExecutable_ = false) {
-throw new Error('Function Path_exists is missing on this target in sync context.');
+const fs_ = import$0;
+const fsPromises_ = import$1;
+const flagsR_ = (fs_.constants["R_OK"] * checkReadable_);
+const flagsW_ = (fs_.constants["W_OK"] * checkWritable_);
+const flagsX_ = (fs_.constants["X_OK"] * checkExecutable_);
+const flags_ = ff_core_Int.Int_bitOr(flagsR_, ff_core_Int.Int_bitOr(flagsW_, flagsX_));
+try {
+fsPromises_.access(self_.absolutePath_, ((flags_ === 0)
+? fs_.constants["F_OK"]
+: flags_));
+return true
+} catch {
+return false
+}
 }
 
 export function Path_isReadable(self_) {
@@ -173,39 +372,81 @@ return ff_core_Path.Path_exists(self_, false, false, true)
 }
 
 export function Path_isDirectory(self_) {
-throw new Error('Function Path_isDirectory is missing on this target in sync context.');
+const fsPromises_ = import$1;
+try {
+return fsPromises_.lstat(self_.absolutePath_).isDirectory()
+} catch {
+return false
+}
 }
 
 export function Path_isFile(self_) {
-throw new Error('Function Path_isFile is missing on this target in sync context.');
+const fsPromises_ = import$1;
+try {
+return fsPromises_.lstat(self_.absolutePath_).isFile()
+} catch {
+return false
+}
 }
 
 export function Path_isSymbolicLink(self_) {
-throw new Error('Function Path_isSymbolicLink is missing on this target in sync context.');
+const fsPromises_ = import$1;
+try {
+return fsPromises_.lstat(self_.absolutePath_).isSymbolicLink()
+} catch {
+return false
+}
 }
 
 export function Path_isInsideOf(self_, path_) {
-throw new Error('Function Path_isInsideOf is missing on this target in sync context.');
+const nodePath_ = import$2;
+if((path_.absolutePath_ === "/")) {
+return true
+} else {
+const childPath_ = self_.absolutePath_;
+const parentPath_ = path_.absolutePath_;
+return (ff_core_String.String_startsWith(childPath_, (parentPath_ + nodePath_.sep), 0) || (childPath_ === parentPath_))
+}
 }
 
 export function Path_size(self_) {
-throw new Error('Function Path_size is missing on this target in sync context.');
+const fs_ = import$0;
+return fs_.promises.stat(self_.absolutePath_)
 }
 
 export function Path_modified(self_) {
-throw new Error('Function Path_modified is missing on this target in sync context.');
+const fs_ = import$0;
+return (fs_.promises.stat(self_.absolutePath_).mtimeMs * 0.001)
 }
 
 export function Path_entries(self_) {
-throw new Error('Function Path_entries is missing on this target in sync context.');
+const fsPromises_ = import$1;
+let dir_ = null;
+return ff_core_Stream.Stream((() => {
+if(ff_core_JsValue.JsValue_isNull(dir_)) {
+dir_ = fsPromises_.opendir(self_.absolutePath_, {bufferSize: 128})
+};
+const entry_ = dir_.read();
+if((!ff_core_JsValue.JsValue_isNull(entry_))) {
+return ff_core_Option.Some((function() {
+entry_.ffPath = self_.absolutePath_;
+return entry_
+})())
+} else return ff_core_Option.None()
+}), (() => {
+if((!ff_core_JsValue.JsValue_isNull(dir_))) {
+dir_.close()
+}
+}))
 }
 
 export function Path_absolute(self_) {
-throw new Error('Function Path_absolute is missing on this target in sync context.');
+return self_.absolutePath_
 }
 
 export function Path_relativeTo(self_, path_) {
-throw new Error('Function Path_relativeTo is missing on this target in sync context.');
+const nodePath_ = import$2;
+return nodePath_.relative(path_.absolutePath_, self_.absolutePath_)
 }
 
 export function Path_endsWith(self_, parts_) {
@@ -221,7 +462,7 @@ const p_ = reversed_a[0];
 const ps_ = reversed_a.slice(1);
 return ((ff_core_Path.Path_base(path_) === p_) && go_(ff_core_Path.Path_parent(path_), ps_))
 }
-if(pathOption_a.None) {
+{
 return false
 }
 }
@@ -235,35 +476,46 @@ return ff_core_Path.Path_contains(_w1, parts_)
 }
 
 export function Path_base(self_) {
-throw new Error('Function Path_base is missing on this target in sync context.');
+const path_ = import$2;
+return path_.basename(self_.absolutePath_)
 }
 
 export function Path_extension(self_) {
-throw new Error('Function Path_extension is missing on this target in sync context.');
+const path_ = import$2;
+return path_.extname(self_.absolutePath_)
 }
 
 export function Path_url(self_) {
-throw new Error('Function Path_url is missing on this target in sync context.');
+const url_ = import$3;
+return ("" + url_.pathToFileURL(self_.absolutePath_))
 }
 
 export function Path_delimiter(self_) {
-throw new Error('Function Path_delimiter is missing on this target in sync context.');
+const path_ = import$2;
+return path_.delimiter(self_.absolutePath_)
 }
 
 export function Path_separator(self_) {
-throw new Error('Function Path_separator is missing on this target in sync context.');
+const path_ = import$2;
+return path_.separator(self_.absolutePath_)
 }
 
 export function Path_parent(self_) {
-throw new Error('Function Path_parent is missing on this target in sync context.');
+const path_ = import$2;
+const result_ = path_.dirname(self_.absolutePath_);
+if(((result_ !== "") && (result_ !== self_.absolutePath_))) {
+return ff_core_Option.Some(ff_core_Path.Path(result_))
+} else return ff_core_Option.None()
 }
 
 export function Path_slash(self_, relativePath_) {
-throw new Error('Function Path_slash is missing on this target in sync context.');
+const path_ = import$2;
+return ff_core_Path.Path(path_.join(self_.absolutePath_, relativePath_))
 }
 
 export function Path_path(self_, absoluteOrRelativePath_) {
-throw new Error('Function Path_path is missing on this target in sync context.');
+const path_ = import$2;
+return ff_core_Path.Path(path_.resolve(self_.absolutePath_, absoluteOrRelativePath_))
 }
 
 export function Path_copyTo(self_, path_, retries_ = 0, retryDelay_ = 100) {
@@ -283,39 +535,56 @@ ff_core_Path.Path_writeStream(path_, ff_core_Path.Path_readStream(self_), false)
 }
 
 export function Path_createDirectory(self_, createParentDirectories_ = false) {
-throw new Error('Function Path_createDirectory is missing on this target in sync context.');
+const fsPromises_ = import$1;
+fsPromises_.mkdir(self_.absolutePath_, {recursive: createParentDirectories_})
 }
 
 export function Path_createSymlinkTo(self_, path_, junction_ = false) {
-throw new Error('Function Path_createSymlinkTo is missing on this target in sync context.');
+const fsPromises_ = import$1;
+fsPromises_.symlink(path_.absolutePath_, self_.absolutePath_, (junction_
+? "junction"
+: null))
 }
 
 export function Path_delete(self_, retries_ = 0, retryDelay_ = 100) {
-throw new Error('Function Path_delete is missing on this target in sync context.');
+const fsPromises_ = import$1;
+fsPromises_.rm(self_.absolutePath_, {recursive: true, retries: retries_, retryDelay: retryDelay_})
 }
 
 export function Path_truncate(self_, length_ = 0) {
-throw new Error('Function Path_truncate is missing on this target in sync context.');
+const fsPromises_ = import$1;
+fsPromises_.truncate(self_.absolutePath_, length_)
 }
 
 export function Path_renameTo(self_, path_) {
-throw new Error('Function Path_renameTo is missing on this target in sync context.');
+const fsPromises_ = import$1;
+fsPromises_.rename(self_.absolutePath_, path_.absolutePath_)
 }
 
 export function Path_readSymbolicLink(self_) {
-throw new Error('Function Path_readSymbolicLink is missing on this target in sync context.');
+const fsPromises_ = import$1;
+return fsPromises_.readlink(self_.absolutePath_)
 }
 
 export function Path_readText(self_) {
-throw new Error('Function Path_readText is missing on this target in sync context.');
+const fsPromises_ = import$1;
+return ff_core_Js.withSignal_(((signal_) => {
+return fsPromises_.readFile(self_.absolutePath_, {encoding: "UTF-8", signal: signal_})
+}))
 }
 
 export function Path_writeText(self_, text_) {
-throw new Error('Function Path_writeText is missing on this target in sync context.');
+const fsPromises_ = import$1;
+ff_core_Js.withSignal_(((signal_) => {
+return fsPromises_.writeFile(self_.absolutePath_, text_, {encoding: "UTF-8", signal: signal_})
+}))
 }
 
 export function Path_appendText(self_, text_) {
-throw new Error('Function Path_appendText is missing on this target in sync context.');
+const fsPromises_ = import$1;
+ff_core_Js.withSignal_(((signal_) => {
+return fsPromises_.appendFile(self_.absolutePath_, text_, {encoding: "UTF-8", signal: signal_})
+}))
 }
 
 export function Path_readBuffer(self_) {
@@ -331,44 +600,64 @@ ff_core_Path.Path_appendStream(self_, ff_core_List.List_toStream([buffer_], fals
 }
 
 export function Path_readStream(self_) {
-throw new Error('Function Path_readStream is missing on this target in sync context.');
+const fs_ = import$0;
+return ff_core_Path.internalReadStream_((() => {
+return fs_.createReadStream(self_.absolutePath_)
+}))
 }
 
 export function Path_writeStream(self_, stream_, createOnly_ = false) {
-throw new Error('Function Path_writeStream is missing on this target in sync context.');
+ff_core_Path.internalWriteStream_(self_, stream_, (createOnly_
+? "wx"
+: "w"))
 }
 
 export function Path_appendStream(self_, stream_) {
-throw new Error('Function Path_appendStream is missing on this target in sync context.');
+ff_core_Path.internalWriteStream_(self_, stream_, "a")
 }
 
 export function Path_readHandle(self_, alsoWrite_ = false) {
-throw new Error('Function Path_readHandle is missing on this target in sync context.');
+const fsPromises_ = import$1;
+return fsPromises_.open(self_.absolutePath_, (alsoWrite_
+? "r+"
+: "r"))
 }
 
 export function Path_writeHandle(self_, alsoRead_ = false, mustCreate_ = false) {
-throw new Error('Function Path_writeHandle is missing on this target in sync context.');
+const fsPromises_ = import$1;
+const flags_ = ((mustCreate_
+? "wx"
+: "w") + (alsoRead_
+? "+"
+: ""));
+return fsPromises_.open(self_.absolutePath_, flags_)
 }
 
 export function Path_appendHandle(self_, alsoRead_ = false, mustCreate_ = false) {
-throw new Error('Function Path_appendHandle is missing on this target in sync context.');
+const fsPromises_ = import$1;
+const flags_ = ((mustCreate_
+? "ax"
+: "a") + (alsoRead_
+? "+"
+: ""));
+return fsPromises_.open(self_.absolutePath_, flags_)
 }
 
 export async function Path_exists$(self_, checkReadable_ = false, checkWritable_ = false, checkExecutable_ = false, $task) {
-
-            const fs = import$0
-            const fsPromises = import$1
-            const flags = 
-                (fs.constants.R_OK * checkReadable_) | 
-                (fs.constants.W_OK * checkWritable_) | 
-                (fs.constants.X_OK * checkExecutable_)
-            try {
-                await fsPromises.access(self_, flags === 0 ? fs.constants.F_OK : flags)
-                return true
-            } catch(e) {
-                return false
-            }
-        
+const fs_ = import$0;
+const fsPromises_ = import$1;
+const flagsR_ = (fs_.constants["R_OK"] * checkReadable_);
+const flagsW_ = (fs_.constants["W_OK"] * checkWritable_);
+const flagsX_ = (fs_.constants["X_OK"] * checkExecutable_);
+const flags_ = ff_core_Int.Int_bitOr(flagsR_, ff_core_Int.Int_bitOr(flagsW_, flagsX_));
+try {
+(await fsPromises_.access(self_.absolutePath_, ((flags_ === 0)
+? fs_.constants["F_OK"]
+: flags_)));
+return true
+} catch {
+return false
+}
 }
 
 export async function Path_isReadable$(self_, $task) {
@@ -384,91 +673,81 @@ return (await ff_core_Path.Path_exists$(self_, false, false, true, $task))
 }
 
 export async function Path_isDirectory$(self_, $task) {
-
-            const fsPromises = import$1
-            try {
-                return (await fsPromises.lstat(self_)).isDirectory();
-            } catch(e) {
-                return false;
-            }
-        
+const fsPromises_ = import$1;
+try {
+return (await fsPromises_.lstat(self_.absolutePath_)).isDirectory()
+} catch {
+return false
+}
 }
 
 export async function Path_isFile$(self_, $task) {
-
-            const fsPromises = import$1
-            try {
-                return (await fsPromises.lstat(self_)).isFile();
-            } catch(e) {
-                return false;
-            }
-        
+const fsPromises_ = import$1;
+try {
+return (await fsPromises_.lstat(self_.absolutePath_)).isFile()
+} catch {
+return false
+}
 }
 
 export async function Path_isSymbolicLink$(self_, $task) {
-
-            const fsPromises = import$1
-            try {
-                return (await fsPromises.lstat(self_)).isSymbolicLink();
-            } catch(e) {
-                return false;
-            }
-        
+const fsPromises_ = import$1;
+try {
+return (await fsPromises_.lstat(self_.absolutePath_)).isSymbolicLink()
+} catch {
+return false
+}
 }
 
 export async function Path_isInsideOf$(self_, path_, $task) {
-
-            const path = import$2
-            if(path_ === '/') return true
-            const childPath = path.resolve(self_)
-            const parentPath = path.resolve(path_)
-            return childPath.startsWith(parentPath + path.sep) || childPath === parentPath
-        
+const nodePath_ = import$2;
+if((path_.absolutePath_ === "/")) {
+return true
+} else {
+const childPath_ = self_.absolutePath_;
+const parentPath_ = path_.absolutePath_;
+return (ff_core_String.String_startsWith(childPath_, (parentPath_ + nodePath_.sep), 0) || (childPath_ === parentPath_))
+}
 }
 
 export async function Path_size$(self_, $task) {
-
-            return (await fs.promises.stat(file)).size
-        
+const fs_ = import$0;
+return (await fs_.promises.stat(self_.absolutePath_))
 }
 
 export async function Path_modified$(self_, $task) {
-
-            return (await fs.promises.stat(file)).mtimeMs * 0.001
-        
+const fs_ = import$0;
+return ((await fs_.promises.stat(self_.absolutePath_)).mtimeMs * 0.001)
 }
 
 export async function Path_entries$(self_, $task) {
-
-            const fsPromises = import$1
-            let dir = null
-            return ff_core_Stream.Stream(
-                async () => {
-                    if(dir === null) dir = await fsPromises.opendir(self_, {bufferSize: 128})
-                    const entry = await dir.read()
-                    if(entry === null) return ff_core_Option.None()
-                    entry.ffPath = self_
-                    return ff_core_Option.Some(entry)
-                },
-                async () => {
-                    if(dir !== null) await dir.close()
-                }
-            )
-        
+const fsPromises_ = import$1;
+let dir_ = null;
+return ff_core_Stream.Stream((async ($task) => {
+if(ff_core_JsValue.JsValue_isNull(dir_)) {
+dir_ = (await fsPromises_.opendir(self_.absolutePath_, {bufferSize: 128}))
+};
+const entry_ = (await dir_.read());
+if((!ff_core_JsValue.JsValue_isNull(entry_))) {
+return ff_core_Option.Some((await (async function() {
+entry_.ffPath = self_.absolutePath_;
+return entry_
+})()))
+} else return ff_core_Option.None()
+}), (async ($task) => {
+if((!ff_core_JsValue.JsValue_isNull(dir_))) {
+(await dir_.close())
+}
+}))
 }
 
 export async function Path_absolute$(self_, $task) {
-
-            const path = import$2
-            return path.resolve(self_)
-        
+return self_.absolutePath_
 }
 
 export async function Path_relativeTo$(self_, path_, $task) {
-
-            const path = import$2;
-            return path.relative(path_, self_);
-        
+const nodePath_ = import$2;
+return nodePath_.relative(path_.absolutePath_, self_.absolutePath_)
 }
 
 export async function Path_endsWith$(self_, parts_, $task) {
@@ -484,7 +763,7 @@ const p_ = reversed_a[0];
 const ps_ = reversed_a.slice(1);
 return (((await ff_core_Path.Path_base$(path_, $task)) === p_) && (await go_$((await ff_core_Path.Path_parent$(path_, $task)), ps_, $task)))
 }
-if(pathOption_a.None) {
+{
 return false
 }
 }
@@ -498,62 +777,46 @@ return (await ff_core_Path.Path_contains$(_w1, parts_, $task))
 }
 
 export async function Path_base$(self_, $task) {
-
-            const path = import$2
-            return path.basename(self_)
-        
+const path_ = import$2;
+return path_.basename(self_.absolutePath_)
 }
 
 export async function Path_extension$(self_, $task) {
-
-            const path = import$2
-            return path.extname(self_)
-        
+const path_ = import$2;
+return path_.extname(self_.absolutePath_)
 }
 
 export async function Path_url$(self_, $task) {
-
-            const url = import$3;
-            return '' + url.pathToFileURL(self_);
-        
+const url_ = import$3;
+return ("" + url_.pathToFileURL(self_.absolutePath_))
 }
 
 export async function Path_delimiter$(self_, $task) {
-
-            const path = import$2;
-            return path.delimiter(self_);
-        
+const path_ = import$2;
+return path_.delimiter(self_.absolutePath_)
 }
 
 export async function Path_separator$(self_, $task) {
-
-            const path = import$2;
-            return path.separator();
-        
+const path_ = import$2;
+return path_.separator(self_.absolutePath_)
 }
 
 export async function Path_parent$(self_, $task) {
-
-            const path = import$2
-            const result = path.dirname(self_)
-            return result !== "" && result !== self_
-                ? ff_core_Option.Some(result) 
-                : ff_core_Option.None()
-        
+const path_ = import$2;
+const result_ = path_.dirname(self_.absolutePath_);
+if(((result_ !== "") && (result_ !== self_.absolutePath_))) {
+return ff_core_Option.Some(ff_core_Path.Path(result_))
+} else return ff_core_Option.None()
 }
 
 export async function Path_slash$(self_, relativePath_, $task) {
-
-            const path = import$2
-            return path.join(self_, relativePath_)
-        
+const path_ = import$2;
+return ff_core_Path.Path(path_.join(self_.absolutePath_, relativePath_))
 }
 
 export async function Path_path$(self_, absoluteOrRelativePath_, $task) {
-
-            const path = import$2
-            return path.resolve(self_, absoluteOrRelativePath_)
-        
+const path_ = import$2;
+return ff_core_Path.Path(path_.resolve(self_.absolutePath_, absoluteOrRelativePath_))
 }
 
 export async function Path_copyTo$(self_, path_, retries_ = 0, retryDelay_ = 100, $task) {
@@ -573,78 +836,56 @@ if((await ff_core_Path.Path_exists$(path_, false, false, false, $task))) {
 }
 
 export async function Path_createDirectory$(self_, createParentDirectories_ = false, $task) {
-
-            const fsPromises = import$1
-            await fsPromises.mkdir(self_, {recursive: createParentDirectories_})
-        
+const fsPromises_ = import$1;
+(await fsPromises_.mkdir(self_.absolutePath_, {recursive: createParentDirectories_}))
 }
 
 export async function Path_createSymlinkTo$(self_, path_, junction_ = false, $task) {
-
-            const fsPromises = import$1
-            await fsPromises.symlink(path_, self_, junction_ ? 'junction' : null)
-        
+const fsPromises_ = import$1;
+(await fsPromises_.symlink(path_.absolutePath_, self_.absolutePath_, (junction_
+? "junction"
+: null)))
 }
 
 export async function Path_delete$(self_, retries_ = 0, retryDelay_ = 100, $task) {
-
-            const fsPromises = import$1
-            await fsPromises.rm(self_, {recursive: true, retries: retries_, retryDelay: retryDelay_})
-        
+const fsPromises_ = import$1;
+(await fsPromises_.rm(self_.absolutePath_, {recursive: true, retries: retries_, retryDelay: retryDelay_}))
 }
 
 export async function Path_truncate$(self_, length_ = 0, $task) {
-
-            const fsPromises = import$1
-            await fsPromises.truncate(self_, length_)
-        
+const fsPromises_ = import$1;
+(await fsPromises_.truncate(self_.absolutePath_, length_))
 }
 
 export async function Path_renameTo$(self_, path_, $task) {
-
-            const fsPromises = import$1
-            await fsPromises.rename(self_, path_)
-        
+const fsPromises_ = import$1;
+(await fsPromises_.rename(self_.absolutePath_, path_.absolutePath_))
 }
 
 export async function Path_readSymbolicLink$(self_, $task) {
-
-            const fsPromises = import$1
-            return await fsPromises.readlink(self_)
-        
+const fsPromises_ = import$1;
+return (await fsPromises_.readlink(self_.absolutePath_))
 }
 
 export async function Path_readText$(self_, $task) {
-
-            const fsPromises = import$1
-            try {
-                return await fsPromises.readFile(self_, {encoding: 'UTF-8', signal: $task.controller.signal})
-            } finally {
-                if($task.controller.signal.aborted) $task.controller = new AbortController()
-            }
-        
+const fsPromises_ = import$1;
+return (await ff_core_Js.withSignal_$((async (signal_, $task) => {
+return (await fsPromises_.readFile(self_.absolutePath_, {encoding: "UTF-8", signal: signal_}))
+}), $task))
 }
 
 export async function Path_writeText$(self_, text_, $task) {
-
-            const fsPromises = import$1
-            try {
-                await fsPromises.writeFile(self_, text_, {encoding: 'UTF-8', signal: $task.controller.signal})
-            } finally {
-                if($task.controller.signal.aborted) $task.controller = new AbortController()
-            }
-        
+const fsPromises_ = import$1;
+(await ff_core_Js.withSignal_$((async (signal_, $task) => {
+return (await fsPromises_.writeFile(self_.absolutePath_, text_, {encoding: "UTF-8", signal: signal_}))
+}), $task))
 }
 
 export async function Path_appendText$(self_, text_, $task) {
-
-            const fsPromises = import$1
-            try {
-                await fsPromises.appendFile(self_, text_, {encoding: 'UTF-8', signal: $task.controller.signal})
-            } finally {
-                if($task.controller.signal.aborted) $task.controller = new AbortController()
-            }
-        
+const fsPromises_ = import$1;
+(await ff_core_Js.withSignal_$((async (signal_, $task) => {
+return (await fsPromises_.appendFile(self_.absolutePath_, text_, {encoding: "UTF-8", signal: signal_}))
+}), $task))
 }
 
 export async function Path_readBuffer$(self_, $task) {
@@ -660,120 +901,81 @@ export async function Path_appendBuffer$(self_, buffer_, $task) {
 }
 
 export async function Path_readStream$(self_, $task) {
-
-            const fs = import$0
-            return ff_core_Path.internalReadStream_$(() => fs.createReadStream(self_))
-        
+const fs_ = import$0;
+return (await ff_core_Path.internalReadStream_$((async ($task) => {
+return fs_.createReadStream(self_.absolutePath_)
+}), $task))
 }
 
 export async function Path_writeStream$(self_, stream_, createOnly_ = false, $task) {
-
-            const fs = import$0
-            let writeable = fs.createWriteStream(self_, {flags: createOnly_ ? 'wx' : 'w'})
-            try {
-                await ff_core_Stream.Stream_each$(stream_, async buffer => {
-                    if(!writeable.write(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength))) {
-                        await new Promise((resolve, reject) => {
-                            $task.controller.signal.addEventListener('abort', reject)
-                            writeable.once('drain', () => {
-                                $task.controller.signal.removeEventListener('abort', reject)
-                                resolve()
-                            })
-                        })
-                    }
-                }, $task)
-            } finally {
-                await new Promise((resolve, reject) => {
-                    writeable.close(err => {if(err) reject(err); else resolve();});
-                });
-            }
-        
+(await ff_core_Path.internalWriteStream_$(self_, stream_, (createOnly_
+? "wx"
+: "w"), $task))
 }
 
 export async function Path_appendStream$(self_, stream_, $task) {
-
-            const fs = import$0
-            let writeable = fs.createWriteStream(self_, {flags: 'a'})
-            try {
-                await ff_core_Stream.Stream_each$(stream_, async buffer => {
-                    if(!writeable.write(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength))) {
-                        await new Promise((resolve, reject) => {
-                            $task.controller.signal.addEventListener('abort', reject)
-                            writeable.once('drain', () => {
-                                $task.controller.signal.removeEventListener('abort', reject)
-                                resolve()
-                            })
-                        })
-                    }
-                }, $task)
-            } finally {
-                await new Promise((resolve, reject) => {
-                    writeable.close(err => {if(err) reject(err); else resolve();});
-                });
-            }
-        
+(await ff_core_Path.internalWriteStream_$(self_, stream_, "a", $task))
 }
 
 export async function Path_readHandle$(self_, alsoWrite_ = false, $task) {
-
-            const fsPromises = import$1
-            return await fsPromises.open(self_, alsoWrite_ ? 'r+' : 'r')
-        
+const fsPromises_ = import$1;
+return (await fsPromises_.open(self_.absolutePath_, (alsoWrite_
+? "r+"
+: "r")))
 }
 
 export async function Path_writeHandle$(self_, alsoRead_ = false, mustCreate_ = false, $task) {
-
-            const fsPromises = import$1
-            return await fsPromises.open(self_, (mustCreate_ ? 'wx' : 'w') + (alsoRead_ ? '+' : ''))
-        
+const fsPromises_ = import$1;
+const flags_ = ((mustCreate_
+? "wx"
+: "w") + (alsoRead_
+? "+"
+: ""));
+return (await fsPromises_.open(self_.absolutePath_, flags_))
 }
 
 export async function Path_appendHandle$(self_, alsoRead_ = false, mustCreate_ = false, $task) {
-
-            const fsPromises = import$1
-            return await fsPromises.open(self_, (mustCreate_ ? 'wx' : 'w') + (alsoRead_ ? '+' : ''))
-        
+const fsPromises_ = import$1;
+const flags_ = ((mustCreate_
+? "ax"
+: "a") + (alsoRead_
+? "+"
+: ""));
+return (await fsPromises_.open(self_.absolutePath_, flags_))
 }
 
 export function PathEntry_path(self_) {
-throw new Error('Function PathEntry_path is missing on this target in sync context.');
+const path_ = import$2;
+return ff_core_Path.Path(path_.join(self_.ffPath, self_.name))
 }
 
 export function PathEntry_isDirectory(self_) {
-throw new Error('Function PathEntry_isDirectory is missing on this target in sync context.');
+return self_.isDirectory()
 }
 
 export function PathEntry_isFile(self_) {
-throw new Error('Function PathEntry_isFile is missing on this target in sync context.');
+return self_.isFile()
 }
 
 export function PathEntry_isSymbolicLink(self_) {
-throw new Error('Function PathEntry_isSymbolicLink is missing on this target in sync context.');
+return self_.isSymbolicLink()
 }
 
 export async function PathEntry_path$(self_, $task) {
-
-            const path = import$2
-            return path.join(self_.ffPath, self_.name)
-        
+const path_ = import$2;
+return ff_core_Path.Path(path_.join(self_.ffPath, self_.name))
 }
 
 export async function PathEntry_isDirectory$(self_, $task) {
-
-            return self_.isDirectory()
-        
+return self_.isDirectory()
 }
 
 export async function PathEntry_isFile$(self_, $task) {
-
-            return self_.isFile()
-        
+return self_.isFile()
 }
 
 export async function PathEntry_isSymbolicLink$(self_, $task) {
-
-            return self_.isSymbolicLink()
-        
+return self_.isSymbolicLink()
 }