firefly-compiler 0.5.39 → 0.5.40

package/core/Path.ff

@@ -1,378 +1,377 @@
-capability Path(absolutePath: String)
-capability PathEntry {}
-
-extend self: Path {
-
-    exists(checkReadable: Bool = False, checkWritable: Bool = False, checkExecutable: Bool = False): Bool {
-        let fs = Js.import("fs")
-        let fsPromises = Js.import("fs/promises")
-        let flagsR: Int = (fs->constants->"R_OK" * checkReadable!)?
-        let flagsW: Int = (fs->constants->"W_OK" * checkWritable!)?
-        let flagsX: Int = (fs->constants->"X_OK" * checkExecutable!)?
-        let flags = flagsR.bitOr(flagsW.bitOr(flagsX))
-        try {
-            Js.await(
-                fsPromises->access(self.absolutePath, if(flags == 0) {fs->constants->"F_OK"} else {flags!})
-            )
-            True
-        } catchAny {_ => 
-            False
-        }
-    }
-
-    isReadable(): Bool {
-        self.exists(checkReadable = True)
-    }
-        
-    isWritable(): Bool {
-        self.exists(checkWritable = True)
-    }
-
-    isExecutable(): Bool {
-        self.exists(checkExecutable = True)
-    }
-
-    isDirectory(): Bool {
-        let fsPromises = Js.import("fs/promises")        
-        try {
-            Js.await(fsPromises->lstat(self.absolutePath))->isDirectory()?
-        } catchAny {_ => 
-            False
-        }
-    }
-
-    isFile(): Bool {
-        let fsPromises = Js.import("fs/promises")        
-        try {
-            Js.await(fsPromises->lstat(self.absolutePath))->isFile()?
-        } catchAny {_ => 
-            False
-        }        
-    }
-
-    isSymbolicLink(): Bool {
-        let fsPromises = Js.import("fs/promises")        
-        try {
-            Js.await(fsPromises->lstat(self.absolutePath))->isSymbolicLink()?
-        } catchAny {_ => 
-            False
-        }        
-    }
-
-    isInsideOf(path: Path): Bool {
-        let nodePath = Js.import("path")
-        if(path.absolutePath == "/") {True} else:
-        let childPath = self.absolutePath
-        let parentPath = path.absolutePath
-        childPath.startsWith(parentPath + nodePath->sep?) || childPath == parentPath
-    }
-    
-    size(): Int {
-        let fs = Js.import("fs")
-        Js.await(fs->promises->stat(self.absolutePath))?
-    }
-        
-    modified(): Instant {
-        let fs = Js.import("fs")
-        (Js.await(fs->promises->stat(self.absolutePath))->mtimeMs * 0.001!)?
-    }
-
-    entries(): Stream[PathEntry] {
-        let fsPromises = Js.import("fs/promises")
-        mutable dir = Js.null()
-        Stream {
-            if(dir.isNull()) {
-                dir = Js.await(fsPromises->opendir(self.absolutePath, Js->(bufferSize = 128)))
-            }
-            let entry = Js.await(dir->read())
-            if(!entry.isNull()) {
-                entry->ffPath = self.absolutePath
-                entry?
-            }
-        } {
-            if(!dir.isNull()) {
-                Js.await(dir->close())
-            }
-        }
-    }
-
-    absolute(): String {
-        self.absolutePath
-    }
-
-    relativeTo(path: Path): String {
-        let nodePath = Js.import("path")        
-        nodePath->relative(path.absolutePath, self.absolutePath)?
-    }
-    
-    endsWith(parts: List[String]): Bool {
-        function go(pathOption: Option[Path], reversed: List[String]): Bool {
-            | _, [] => True
-            | Some(path), [p, ...ps] => path.base() == p && go(path.parent(), ps)
-            | None, _ => False
-        }
-        go(Some(self), parts.reverse())
-    }
-
-    contains(parts: List[String]): Bool {
-        self.endsWith(parts) || self.parent().any {_.contains(parts)}
-    }
-
-    base(): String {
-        let path = Js.import("path")
-        path->basename(self.absolutePath)?        
-    }
-
-    extension(): String {
-        let path = Js.import("path")
-        path->extname(self.absolutePath)?
-    }
-
-    url(): String {
-        let url = Js.import("url")
-        "" + url->pathToFileURL(self.absolutePath)?        
-    }
-
-    delimiter(): String {
-        let path = Js.import("path")
-        path->delimiter(self.absolutePath)?        
-    }
-
-    separator(): String {
-        let path = Js.import("path")
-        path->separator(self.absolutePath)?        
-    }
-
-    parent(): Option[Path] {
-        let path = Js.import("path")
-        let result: String = path->dirname(self.absolutePath)?
-        if(result != "" && result != self.absolutePath) {Path(result)}
-    }
-
-    slash(relativePath: String): Path {
-        let path = Js.import("path")
-        Path(path->join(self.absolutePath, relativePath)?)
-    }
-
-    path(absoluteOrRelativePath: String): Path {
-        let path = Js.import("path")
-        Path(path->resolve(self.absolutePath, absoluteOrRelativePath)?)
-    }
-
-    copyTo(path: Path, retries: Int = 0, retryDelay: Int = 100) {
-        if(self.isDirectory()) {
-            if(path.exists()) {path.delete(retries, retryDelay)}
-            path.createDirectory()
-            self.entries().each {file =>
-                file.path().copyTo(path.slash(file.path().relativeTo(self)), retries, retryDelay)
-            }
-        } elseIf {self.isSymbolicLink()} {
-            Log.debug("Copying link: " + path.absolutePath + " -> " + self.path(self.readSymbolicLink()).absolutePath)
-            path.createSymlinkTo(self.path(self.readSymbolicLink()), junction = True)
-        } else {
-            path.writeStream(self.readStream())
-        }
-    }
-
-    createDirectory(createParentDirectories: Bool = False) {
-        let fsPromises = Js.import("fs/promises")
-        Js.await(fsPromises->mkdir(self.absolutePath, Js->(recursive = createParentDirectories)))
-    }
-
-    createSymlinkTo(path: Path, junction: Bool = False) {
-        let fsPromises = Js.import("fs/promises")
-        Js.await(fsPromises->symlink(path.absolutePath, self.absolutePath, if(junction) {"junction"!} else {Js.null()}))
-    }
-
-    delete(retries: Int = 0, retryDelay: Int = 100) {
-        let fsPromises = Js.import("fs/promises")
-        Js.await(fsPromises->rm(self.absolutePath, Js->(recursive = True, retries = retries, retryDelay = retryDelay)))
-    }
-    
-    truncate(length: Int = 0) {
-        let fsPromises = Js.import("fs/promises")
-        Js.await(fsPromises->truncate(self.absolutePath, length))
-    }
-
-    renameTo(path: Path) {
-        let fsPromises = Js.import("fs/promises")
-        Js.await(fsPromises->rename(self.absolutePath, path.absolutePath))
-    }
-
-    readSymbolicLink(): String {
-        let fsPromises = Js.import("fs/promises")
-        Js.await(fsPromises->readlink(self.absolutePath))?
-    }
-
-    readText(): String {
-        let fsPromises = Js.import("fs/promises")
-        Js.withSignal {signal =>
-            Js.await(fsPromises->readFile(self.absolutePath, Js->(encoding = "UTF-8", signal = signal)))?
-        }
-    }
-
-    writeText(text: String) {
-        let fsPromises = Js.import("fs/promises")
-        Js.withSignal {signal =>
-            Js.await(fsPromises->writeFile(self.absolutePath, text, Js->(encoding = "UTF-8", signal = signal)))
-        }
-    }
-
-    appendText(text: String) {
-        let fsPromises = Js.import("fs/promises")
-        Js.withSignal {signal =>
-            Js.await(fsPromises->appendFile(self.absolutePath, text, Js->(encoding = "UTF-8", signal = signal)))
-        }
-    }
-
-    readBuffer(): Buffer {
-        self.readStream().toBuffer()
-    }
-    
-    writeBuffer(buffer: Buffer) {
-        self.writeStream([buffer].toStream())
-    }
-    
-    appendBuffer(buffer: Buffer) {
-        self.appendStream([buffer].toStream())
-    }
-
-    readStream(): Stream[Buffer] {
-        let fs = Js.import("fs")
-        internalReadStream {fs->createReadStream(self.absolutePath)}
-    }
-    
-    writeStream(stream: Stream[Buffer], createOnly: Bool = False) {
-        internalWriteStream(self, stream, if(createOnly) {"wx"} else {"w"})
-    }
-
-    appendStream(stream: Stream[Buffer]) {
-        internalWriteStream(self, stream, "a")
-    }
-
-    readHandle(alsoWrite: Bool = False): FileHandle {
-        let fsPromises = Js.import("fs/promises")
-        Js.await(fsPromises->open(self.absolutePath, if(alsoWrite) {"r+"} else {"r"}))?
-    }
-
-    writeHandle(alsoRead: Bool = False, mustCreate: Bool = False): FileHandle {
-        let fsPromises = Js.import("fs/promises")
-        let flags = if(mustCreate) {"wx"} else {"w"} + if(alsoRead) {"+"} else {""}
-        Js.await(fsPromises->open(self.absolutePath, flags))?
-    }
-   
-    appendHandle(alsoRead: Bool = False, mustCreate: Bool = False): FileHandle {
-        let fsPromises = Js.import("fs/promises")
-        let flags = if(mustCreate) {"ax"} else {"a"} + if(alsoRead) {"+"} else {""}
-        Js.await(fsPromises->open(self.absolutePath, flags))?
-    }
-
-}
-
-extend self: PathEntry {
-    
-    path(): Path {
-        let path = Js.import("path")
-        Path(path->join(self!->ffPath, self!->name)?)
-    }
-
-    isDirectory(): Bool {
-        self!->isDirectory()?
-    }
-
-    isFile(): Bool {
-        self!->isFile()?
-    }
-
-    isSymbolicLink(): Bool {
-        self!->isSymbolicLink()?
-    }
-
-}
-
-internalReadStream(createReadStream: () => JsValue): Stream[Buffer] {
-    mutable readable = None
-    mutable seenError = Js.null()
-    let emptyResolve = {}
-    let emptyReject = {_ => }
-    mutable doResolve = emptyResolve
-    mutable doReject = emptyReject
-    let open = {
-        let newReadable = createReadStream()
-        newReadable->on("readable", Js->{
-            doResolve()
-        })
-        newReadable->on("error", Js->{error =>
-            seenError = error
-            doReject(error)
-        })
-        newReadable->on("close", Js->{
-            doResolve()
-        })
-        readable = Some(newReadable)
-        newReadable
-    }
-    Stream {
-        Js.throwIfCancelled()
-        let jsStream = readable.else(open)
-        function go(): Option[Buffer] {
-            let jsBuffer = jsStream->read()
-            if(!jsBuffer.isNullOrUndefined()) {
-                let buffer: Buffer = Js->DataView->(jsBuffer->buffer, jsBuffer->byteOffset, jsBuffer->length)?
-                Some(buffer)
-            } else:
-            if(!seenError.isNullOrUndefined()) {
-                throwAny(seenError?)
-            } else:
-            if(jsStream->destroyed?) {None} else:
-            Js.withSignal {signal =>
-                let promise = Js->Promise->(Js->{resolve, reject =>
-                    let jsDoReject = Js->{doReject(_)}
-                    doResolve = {
-                        signal->removeEventListener("abort", jsDoReject)
-                        doResolve = emptyResolve
-                        doReject = emptyReject
-                        resolve.callValue0()
-                    }
-                    doReject = {error => 
-                        signal->removeEventListener("abort", jsDoReject)
-                        doResolve = emptyResolve
-                        doReject = emptyReject
-                        reject.callValue1(error)
-                    }
-                    signal->addEventListener("abort", jsDoReject)
-                })
-                Js.await(promise)
-            }
-            tailcall go()
-        }
-        go()
-    } {
-        readable.each {_->destroy()}
-    }
-}
-
-internalWriteStream(path: Path, stream: Stream[Buffer], flags: String) {
-    let fs = Js.import("fs")
-    let writable = fs->createWriteStream(path.absolutePath, Js->(flags = flags))
-    try {
-        stream.each {buffer =>
-            if(!writable->write(Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength))?) {
-                Js.withSignal {signal =>
-                    Js.await(Js->Promise->(Js->{resolve, reject =>
-                        signal->addEventListener("abort", reject)
-                        writable->once("drain", Js->{
-                            signal->removeEventListener("abort", reject)
-                            resolve.callValue0()
-                        })
-                    }))
-                }
-            }
-        }
-    } finally {
-        Js.await(Js->Promise->(Js->{resolve, reject =>
-            writable->close(Js->{err => if(err?) {reject.callValue1(err)} else {resolve.callValue0()}})
-        }))
-    }
-}
-
+capability Path(absolutePath: String)
+capability PathEntry {}
+
+extend self: Path {
+
+    exists(checkReadable: Bool = False, checkWritable: Bool = False, checkExecutable: Bool = False): Bool {
+        let fs = Js.import("fs")
+        let fsPromises = Js.import("fs/promises")
+        let flagsR: Int = (fs->constants->"R_OK" * checkReadable!)?
+        let flagsW: Int = (fs->constants->"W_OK" * checkWritable!)?
+        let flagsX: Int = (fs->constants->"X_OK" * checkExecutable!)?
+        let flags = flagsR.bitOr(flagsW.bitOr(flagsX))
+        try {
+            Js.await(
+                fsPromises->access(self.absolutePath, if(flags == 0) {fs->constants->"F_OK"} else {flags!})
+            )
+            True
+        } catchAny {_ => 
+            False
+        }
+    }
+
+    isReadable(): Bool {
+        self.exists(checkReadable = True)
+    }
+        
+    isWritable(): Bool {
+        self.exists(checkWritable = True)
+    }
+
+    isExecutable(): Bool {
+        self.exists(checkExecutable = True)
+    }
+
+    isDirectory(): Bool {
+        let fsPromises = Js.import("fs/promises")        
+        try {
+            Js.await(fsPromises->lstat(self.absolutePath))->isDirectory()?
+        } catchAny {_ => 
+            False
+        }
+    }
+
+    isFile(): Bool {
+        let fsPromises = Js.import("fs/promises")        
+        try {
+            Js.await(fsPromises->lstat(self.absolutePath))->isFile()?
+        } catchAny {_ => 
+            False
+        }        
+    }
+
+    isSymbolicLink(): Bool {
+        let fsPromises = Js.import("fs/promises")        
+        try {
+            Js.await(fsPromises->lstat(self.absolutePath))->isSymbolicLink()?
+        } catchAny {_ => 
+            False
+        }        
+    }
+
+    isInsideOf(path: Path): Bool {
+        let nodePath = Js.import("path")
+        if(path.absolutePath == "/") {True} else:
+        let childPath = self.absolutePath
+        let parentPath = path.absolutePath
+        childPath.startsWith(parentPath + nodePath->sep?) || childPath == parentPath
+    }
+    
+    size(): Int {
+        let fs = Js.import("fs")
+        Js.await(fs->promises->stat(self.absolutePath))?
+    }
+        
+    modified(): Instant {
+        let fs = Js.import("fs")
+        (Js.await(fs->promises->stat(self.absolutePath))->mtimeMs * 0.001!)?
+    }
+
+    entries(): Stream[PathEntry] {
+        let fsPromises = Js.import("fs/promises")
+        mutable dir = Js.null()
+        Stream {
+            if(dir.isNull()) {
+                dir = Js.await(fsPromises->opendir(self.absolutePath, Js->(bufferSize = 128)))
+            }
+            let entry = Js.await(dir->read())
+            if(!entry.isNull()) {
+                entry->ffPath = self.absolutePath
+                entry?
+            }
+        } {
+            if(!dir.isNull()) {
+                Js.await(dir->close())
+            }
+        }
+    }
+
+    absolute(): String {
+        self.absolutePath
+    }
+
+    relativeTo(path: Path): String {
+        let nodePath = Js.import("path")        
+        nodePath->relative(path.absolutePath, self.absolutePath)?
+    }
+    
+    endsWith(parts: List[String]): Bool {
+        function go(pathOption: Option[Path], reversed: List[String]): Bool {
+            | _, [] => True
+            | Some(path), [p, ...ps] => path.base() == p && go(path.parent(), ps)
+            | None, _ => False
+        }
+        go(Some(self), parts.reverse())
+    }
+
+    contains(parts: List[String]): Bool {
+        self.endsWith(parts) || self.parent().any {_.contains(parts)}
+    }
+
+    base(): String {
+        let path = Js.import("path")
+        path->basename(self.absolutePath)?        
+    }
+
+    extension(): String {
+        let path = Js.import("path")
+        path->extname(self.absolutePath)?
+    }
+
+    url(): String {
+        let url = Js.import("url")
+        "" + url->pathToFileURL(self.absolutePath)?        
+    }
+
+    delimiter(): String {
+        let path = Js.import("path")
+        path->delimiter(self.absolutePath)?        
+    }
+
+    separator(): String {
+        let path = Js.import("path")
+        path->separator(self.absolutePath)?        
+    }
+
+    parent(): Option[Path] {
+        let path = Js.import("path")
+        let result: String = path->dirname(self.absolutePath)?
+        if(result != "" && result != self.absolutePath) {Path(result)}
+    }
+
+    slash(relativePath: String): Path {
+        let path = Js.import("path")
+        Path(path->join(self.absolutePath, relativePath)?)
+    }
+
+    path(absoluteOrRelativePath: String): Path {
+        let path = Js.import("path")
+        Path(path->resolve(self.absolutePath, absoluteOrRelativePath)?)
+    }
+
+    copyTo(path: Path, retries: Int = 0, retryDelay: Int = 100) {
+        if(self.isDirectory()) {
+            if(path.exists()) {path.delete(retries, retryDelay)}
+            path.createDirectory()
+            self.entries().each {file =>
+                file.path().copyTo(path.slash(file.path().relativeTo(self)), retries, retryDelay)
+            }
+        } elseIf {self.isSymbolicLink()} {
+            path.createSymlinkTo(self.path(self.readSymbolicLink()), junction = True)
+        } else {
+            path.writeStream(self.readStream())
+        }
+    }
+
+    createDirectory(createParentDirectories: Bool = False) {
+        let fsPromises = Js.import("fs/promises")
+        Js.await(fsPromises->mkdir(self.absolutePath, Js->(recursive = createParentDirectories)))
+    }
+
+    createSymlinkTo(path: Path, junction: Bool = False) {
+        let fsPromises = Js.import("fs/promises")
+        Js.await(fsPromises->symlink(path.absolutePath, self.absolutePath, if(junction) {"junction"!} else {Js.null()}))
+    }
+
+    delete(retries: Int = 0, retryDelay: Int = 100) {
+        let fsPromises = Js.import("fs/promises")
+        Js.await(fsPromises->rm(self.absolutePath, Js->(recursive = True, retries = retries, retryDelay = retryDelay)))
+    }
+    
+    truncate(length: Int = 0) {
+        let fsPromises = Js.import("fs/promises")
+        Js.await(fsPromises->truncate(self.absolutePath, length))
+    }
+
+    renameTo(path: Path) {
+        let fsPromises = Js.import("fs/promises")
+        Js.await(fsPromises->rename(self.absolutePath, path.absolutePath))
+    }
+
+    readSymbolicLink(): String {
+        let fsPromises = Js.import("fs/promises")
+        Js.await(fsPromises->readlink(self.absolutePath))?
+    }
+
+    readText(): String {
+        let fsPromises = Js.import("fs/promises")
+        Js.withSignal {signal =>
+            Js.await(fsPromises->readFile(self.absolutePath, Js->(encoding = "UTF-8", signal = signal)))?
+        }
+    }
+
+    writeText(text: String) {
+        let fsPromises = Js.import("fs/promises")
+        Js.withSignal {signal =>
+            Js.await(fsPromises->writeFile(self.absolutePath, text, Js->(encoding = "UTF-8", signal = signal)))
+        }
+    }
+
+    appendText(text: String) {
+        let fsPromises = Js.import("fs/promises")
+        Js.withSignal {signal =>
+            Js.await(fsPromises->appendFile(self.absolutePath, text, Js->(encoding = "UTF-8", signal = signal)))
+        }
+    }
+
+    readBuffer(): Buffer {
+        self.readStream().toBuffer()
+    }
+    
+    writeBuffer(buffer: Buffer) {
+        self.writeStream([buffer].toStream())
+    }
+    
+    appendBuffer(buffer: Buffer) {
+        self.appendStream([buffer].toStream())
+    }
+
+    readStream(): Stream[Buffer] {
+        let fs = Js.import("fs")
+        internalReadStream {fs->createReadStream(self.absolutePath)}
+    }
+    
+    writeStream(stream: Stream[Buffer], createOnly: Bool = False) {
+        internalWriteStream(self, stream, if(createOnly) {"wx"} else {"w"})
+    }
+
+    appendStream(stream: Stream[Buffer]) {
+        internalWriteStream(self, stream, "a")
+    }
+
+    readHandle(alsoWrite: Bool = False): FileHandle {
+        let fsPromises = Js.import("fs/promises")
+        Js.await(fsPromises->open(self.absolutePath, if(alsoWrite) {"r+"} else {"r"}))?
+    }
+
+    writeHandle(alsoRead: Bool = False, mustCreate: Bool = False): FileHandle {
+        let fsPromises = Js.import("fs/promises")
+        let flags = if(mustCreate) {"wx"} else {"w"} + if(alsoRead) {"+"} else {""}
+        Js.await(fsPromises->open(self.absolutePath, flags))?
+    }
+   
+    appendHandle(alsoRead: Bool = False, mustCreate: Bool = False): FileHandle {
+        let fsPromises = Js.import("fs/promises")
+        let flags = if(mustCreate) {"ax"} else {"a"} + if(alsoRead) {"+"} else {""}
+        Js.await(fsPromises->open(self.absolutePath, flags))?
+    }
+
+}
+
+extend self: PathEntry {
+    
+    path(): Path {
+        let path = Js.import("path")
+        Path(path->join(self!->ffPath, self!->name)?)
+    }
+
+    isDirectory(): Bool {
+        self!->isDirectory()?
+    }
+
+    isFile(): Bool {
+        self!->isFile()?
+    }
+
+    isSymbolicLink(): Bool {
+        self!->isSymbolicLink()?
+    }
+
+}
+
+internalReadStream(createReadStream: () => JsValue): Stream[Buffer] {
+    mutable readable = None
+    mutable seenError = Js.null()
+    let emptyResolve = {}
+    let emptyReject = {_ => }
+    mutable doResolve = emptyResolve
+    mutable doReject = emptyReject
+    let open = {
+        let newReadable = createReadStream()
+        newReadable->on("readable", Js->{
+            doResolve()
+        })
+        newReadable->on("error", Js->{error =>
+            seenError = error
+            doReject(error)
+        })
+        newReadable->on("close", Js->{
+            doResolve()
+        })
+        readable = Some(newReadable)
+        newReadable
+    }
+    Stream {
+        Js.throwIfCancelled()
+        let jsStream = readable.else(open)
+        function go(): Option[Buffer] {
+            let jsBuffer = jsStream->read()
+            if(!jsBuffer.isNullOrUndefined()) {
+                let buffer: Buffer = Js->DataView->(jsBuffer->buffer, jsBuffer->byteOffset, jsBuffer->length)?
+                Some(buffer)
+            } else:
+            if(!seenError.isNullOrUndefined()) {
+                throwAny(seenError?)
+            } else:
+            if(jsStream->destroyed?) {None} else:
+            Js.withSignal {signal =>
+                let promise = Js->Promise->(Js->{resolve, reject =>
+                    let jsDoReject = Js->{doReject(_)}
+                    doResolve = {
+                        signal->removeEventListener("abort", jsDoReject)
+                        doResolve = emptyResolve
+                        doReject = emptyReject
+                        resolve.callValue0()
+                    }
+                    doReject = {error => 
+                        signal->removeEventListener("abort", jsDoReject)
+                        doResolve = emptyResolve
+                        doReject = emptyReject
+                        reject.callValue1(error)
+                    }
+                    signal->addEventListener("abort", jsDoReject)
+                })
+                Js.await(promise)
+            }
+            tailcall go()
+        }
+        go()
+    } {
+        readable.each {_->destroy()}
+    }
+}
+
+internalWriteStream(path: Path, stream: Stream[Buffer], flags: String) {
+    let fs = Js.import("fs")
+    let writable = fs->createWriteStream(path.absolutePath, Js->(flags = flags))
+    try {
+        stream.each {buffer =>
+            if(!writable->write(Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength))?) {
+                Js.withSignal {signal =>
+                    Js.await(Js->Promise->(Js->{resolve, reject =>
+                        signal->addEventListener("abort", reject)
+                        writable->once("drain", Js->{
+                            signal->removeEventListener("abort", reject)
+                            resolve.callValue0()
+                        })
+                    }))
+                }
+            }
+        }
+    } finally {
+        Js.await(Js->Promise->(Js->{resolve, reject =>
+            writable->close(Js->{err => if(err?) {reject.callValue1(err)} else {resolve.callValue0()}})
+        }))
+    }
+}
+