firefly-compiler 0.4.50 → 0.4.52

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

@@ -109,48 +109,48 @@ throw new Error('Function internalReadStream is missing on this target in sync c
 }
 
 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 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)
     
 }
 
@@ -347,19 +347,19 @@ throw new Error('Function Path_appendHandle is missing on this target in sync co
 }
 
 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 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
+            }
         
 }
 
@@ -376,90 +376,90 @@ 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_)).isDirectory();
+            } catch(e) {
+                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_)).isFile();
+            } catch(e) {
+                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_)).isSymbolicLink();
+            } catch(e) {
+                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 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
         
 }
 
 export async function Path_size$(self_, $task) {
-
-            return (await fs.promises.stat(file)).size
+
+            return (await fs.promises.stat(file)).size
         
 }
 
 export async function Path_modified$(self_, $task) {
-
-            return (await fs.promises.stat(file)).mtimeMs * 0.001
+
+            return (await fs.promises.stat(file)).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 () => {
+                    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()
+                }
+            )
         
 }
 
 export async function Path_absolute$(self_, $task) {
-
-            const path = import$2
-            return path.resolve(self_)
+
+            const path = import$2
+            return path.resolve(self_)
         
 }
 
 export async function Path_relativeTo$(self_, path_, $task) {
-
-            const path = import$2;
-            return path.relative(path_, self_);
+
+            const path = import$2;
+            return path.relative(path_, self_);
         
 }
 
@@ -490,61 +490,61 @@ 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_)
         
 }
 
 export async function Path_extension$(self_, $task) {
-
-            const path = import$2
-            return path.extname(self_)
+
+            const path = import$2
+            return path.extname(self_)
         
 }
 
 export async function Path_url$(self_, $task) {
-
-            const url = import$3;
-            return '' + url.pathToFileURL(self_);
+
+            const url = import$3;
+            return '' + url.pathToFileURL(self_);
         
 }
 
 export async function Path_delimiter$(self_, $task) {
-
-            const path = import$2;
-            return path.delimiter(self_);
+
+            const path = import$2;
+            return path.delimiter(self_);
         
 }
 
 export async function Path_separator$(self_, $task) {
-
-            const path = import$2;
-            return path.separator();
+
+            const path = import$2;
+            return path.separator();
         
 }
 
 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_)
+            return result !== "" && result !== self_
+                ? ff_core_Option.Some(result) 
+                : 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 path.join(self_, relativePath_)
         
 }
 
 export async function Path_path$(self_, absoluteOrRelativePath_, $task) {
-
-            const path = import$2
-            return path.resolve(self_, absoluteOrRelativePath_)
+
+            const path = import$2
+            return path.resolve(self_, absoluteOrRelativePath_)
         
 }
 
@@ -563,70 +563,70 @@ 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_, {recursive: createParentDirectories_})
         
 }
 
 export async function Path_createSymlinkTo$(self_, path_, $task) {
-
-            const fsPromises = import$1
-            await fsPromises.symlink(path_, self_)
+
+            const fsPromises = import$1
+            await fsPromises.symlink(path_, self_)
         
 }
 
 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_, {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_, 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_, path_)
         
 }
 
 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
+            try {
+                return await fsPromises.readFile(self_, {encoding: 'UTF-8', signal: $task.controller.signal})
+            } finally {
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
         
 }
 
 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
+            try {
+                await fsPromises.writeFile(self_, text_, {encoding: 'UTF-8', signal: $task.controller.signal})
+            } finally {
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
         
 }
 
 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
+            try {
+                await fsPromises.appendFile(self_, text_, {encoding: 'UTF-8', signal: $task.controller.signal})
+            } finally {
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
         
 }
 
@@ -643,78 +643,78 @@ 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 ff_core_Path.internalReadStream_$(() => fs.createReadStream(self_))
         
 }
 
 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();});
-                });
-            }
+
+            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();});
+                });
+            }
         
 }
 
 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();});
-                });
-            }
+
+            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();});
+                });
+            }
         
 }
 
 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_, 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
+            return await fsPromises.open(self_, (mustCreate_ ? 'wx' : 'w') + (alsoRead_ ? '+' : ''))
         
 }
 
 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
+            return await fsPromises.open(self_, (mustCreate_ ? 'wx' : 'w') + (alsoRead_ ? '+' : ''))
         
 }
 
@@ -735,27 +735,27 @@ throw new Error('Function PathEntry_isSymbolicLink is missing on this target in
 }
 
 export async function PathEntry_path$(self_, $task) {
-
-            const path = import$2
-            return path.join(self_.ffPath, self_.name)
+
+            const path = import$2
+            return 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()
         
 }