@zenfs/dom 0.0.4 → 0.0.6

package/dist/backends/FileSystemAccess.d.ts

@@ -29,7 +29,7 @@ export declare class FileSystemAccessFileSystem extends BaseFileSystem {
     get metadata(): FileSystemMetadata;
     _sync(p: string, data: Uint8Array, stats: Stats, cred: Cred): Promise<void>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    writeFile(fname: string, data: any, encoding: string | null, flag: FileFlag, mode: number, cred: Cred, createFile?: boolean): Promise<void>;
+    writeFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred, createFile?: boolean): Promise<void>;
     createFile(p: string, flag: FileFlag, mode: number, cred: Cred): Promise<FileSystemAccessFile>;
     stat(path: string, cred: Cred): Promise<Stats>;
     exists(p: string, cred: Cred): Promise<boolean>;

package/dist/backends/FileSystemAccess.js

@@ -1,19 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 var _a;
 import { basename, dirname, join } from '@zenfs/core/emulation/path.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
@@ -32,18 +16,14 @@ export class FileSystemAccessFile extends PreloadFile {
     constructor(_fs, _path, _flag, _stat, contents) {
         super(_fs, _path, _flag, _stat, contents);
     }
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isDirty()) {
-                yield this._fs._sync(this.getPath(), this.getBuffer(), this.getStats(), Cred.Root);
-                this.resetDirty();
-            }
-        });
+    async sync() {
+        if (this.isDirty()) {
+            await this._fs._sync(this.getPath(), this.getBuffer(), this.getStats(), Cred.Root);
+            this.resetDirty();
+        }
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sync();
-        });
+    async close() {
+        await this.sync();
     }
 }
 export class FileSystemAccessFileSystem extends BaseFileSystem {
@@ -56,204 +36,170 @@ export class FileSystemAccessFileSystem extends BaseFileSystem {
         this._handles.set('/', handle);
     }
     get metadata() {
-        return Object.assign(Object.assign({}, super.metadata), { name: _a.Name });
-    }
-    _sync(p, data, stats, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentStats = yield this.stat(p, cred);
-            if (stats.mtime !== currentStats.mtime) {
-                yield this.writeFile(p, data, null, FileFlag.getFileFlag('w'), currentStats.mode, cred);
-            }
-        });
-    }
-    rename(oldPath, newPath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const handle = yield this.getHandle(oldPath);
-                if (handle instanceof FileSystemDirectoryHandle) {
-                    const files = yield this.readdir(oldPath, cred);
-                    yield this.mkdir(newPath, 'wx', cred);
-                    if (files.length === 0) {
-                        yield this.unlink(oldPath, cred);
-                    }
-                    else {
-                        for (const file of files) {
-                            yield this.rename(join(oldPath, file), join(newPath, file), cred);
-                            yield this.unlink(oldPath, cred);
-                        }
-                    }
+        return {
+            ...super.metadata,
+            name: _a.Name,
+        };
+    }
+    async _sync(p, data, stats, cred) {
+        const currentStats = await this.stat(p, cred);
+        if (stats.mtime !== currentStats.mtime) {
+            await this.writeFile(p, data, FileFlag.getFileFlag('w'), currentStats.mode, cred);
+        }
+    }
+    async rename(oldPath, newPath, cred) {
+        try {
+            const handle = await this.getHandle(oldPath);
+            if (handle instanceof FileSystemDirectoryHandle) {
+                const files = await this.readdir(oldPath, cred);
+                await this.mkdir(newPath, 'wx', cred);
+                if (files.length === 0) {
+                    await this.unlink(oldPath, cred);
                 }
-                if (handle instanceof FileSystemFileHandle) {
-                    const oldFile = yield handle.getFile(), destFolder = yield this.getHandle(dirname(newPath));
-                    if (destFolder instanceof FileSystemDirectoryHandle) {
-                        const newFile = yield destFolder.getFileHandle(basename(newPath), { create: true });
-                        const writable = yield newFile.createWritable();
-                        const buffer = yield oldFile.arrayBuffer();
-                        yield writable.write(buffer);
-                        writable.close();
-                        yield this.unlink(oldPath, cred);
+                else {
+                    for (const file of files) {
+                        await this.rename(join(oldPath, file), join(newPath, file), cred);
+                        await this.unlink(oldPath, cred);
                     }
                 }
             }
-            catch (err) {
-                handleError(oldPath, err);
-            }
-        });
-    }
-    writeFile(fname, data, encoding, flag, mode, cred, createFile) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(dirname(fname));
-            if (handle instanceof FileSystemDirectoryHandle) {
-                const file = yield handle.getFileHandle(basename(fname), { create: true });
-                const writable = yield file.createWritable();
-                yield writable.write(data);
-                yield writable.close();
-                //return createFile ? this.newFile(fname, flag, data) : undefined;
-            }
-        });
-    }
-    createFile(p, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.writeFile(p, new Uint8Array(), null, flag, mode, cred, true);
-            return this.openFile(p, flag, cred);
-        });
-    }
-    stat(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(path);
-            if (!handle) {
-                throw ApiError.FileError(ErrorCode.EINVAL, path);
-            }
-            if (handle instanceof FileSystemDirectoryHandle) {
-                return new Stats(FileType.DIRECTORY, 4096);
-            }
-            if (handle instanceof FileSystemFileHandle) {
-                const { lastModified, size } = yield handle.getFile();
-                return new Stats(FileType.FILE, size, undefined, undefined, lastModified);
-            }
-        });
-    }
-    exists(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.getHandle(p);
-                return true;
-            }
-            catch (e) {
-                return false;
-            }
-        });
-    }
-    openFile(path, flags, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(path);
             if (handle instanceof FileSystemFileHandle) {
-                const file = yield handle.getFile();
-                const buffer = yield file.arrayBuffer();
-                return this.newFile(path, flags, buffer, file.size, file.lastModified);
-            }
-        });
-    }
-    unlink(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(dirname(path));
-            if (handle instanceof FileSystemDirectoryHandle) {
-                try {
-                    yield handle.removeEntry(basename(path), { recursive: true });
-                }
-                catch (e) {
-                    handleError(path, e);
+                const oldFile = await handle.getFile(), destFolder = await this.getHandle(dirname(newPath));
+                if (destFolder instanceof FileSystemDirectoryHandle) {
+                    const newFile = await destFolder.getFileHandle(basename(newPath), { create: true });
+                    const writable = await newFile.createWritable();
+                    const buffer = await oldFile.arrayBuffer();
+                    await writable.write(buffer);
+                    writable.close();
+                    await this.unlink(oldPath, cred);
                 }
             }
-        });
-    }
-    rmdir(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.unlink(path, cred);
-        });
-    }
-    mkdir(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const overwrite = mode && mode.flag && mode.flag.includes('w') && !mode.flag.includes('x');
-            const existingHandle = yield this.getHandle(p);
-            if (existingHandle && !overwrite) {
-                throw ApiError.EEXIST(p);
-            }
-            const handle = yield this.getHandle(dirname(p));
-            if (handle instanceof FileSystemDirectoryHandle) {
-                yield handle.getDirectoryHandle(basename(p), { create: true });
-            }
-        });
-    }
-    readdir(path, cred) {
-        var _b, e_1, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(path);
-            if (!(handle instanceof FileSystemDirectoryHandle)) {
-                throw ApiError.ENOTDIR(path);
-            }
-            const _keys = [];
+        }
+        catch (err) {
+            handleError(oldPath, err);
+        }
+    }
+    async writeFile(fname, data, flag, mode, cred, createFile) {
+        const handle = await this.getHandle(dirname(fname));
+        if (handle instanceof FileSystemDirectoryHandle) {
+            const file = await handle.getFileHandle(basename(fname), { create: true });
+            const writable = await file.createWritable();
+            await writable.write(data);
+            await writable.close();
+            //return createFile ? this.newFile(fname, flag, data) : undefined;
+        }
+    }
+    async createFile(p, flag, mode, cred) {
+        await this.writeFile(p, new Uint8Array(), flag, mode, cred, true);
+        return this.openFile(p, flag, cred);
+    }
+    async stat(path, cred) {
+        const handle = await this.getHandle(path);
+        if (!handle) {
+            throw ApiError.FileError(ErrorCode.EINVAL, path);
+        }
+        if (handle instanceof FileSystemDirectoryHandle) {
+            return new Stats(FileType.DIRECTORY, 4096);
+        }
+        if (handle instanceof FileSystemFileHandle) {
+            const { lastModified, size } = await handle.getFile();
+            return new Stats(FileType.FILE, size, undefined, undefined, lastModified);
+        }
+    }
+    async exists(p, cred) {
+        try {
+            await this.getHandle(p);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async openFile(path, flags, cred) {
+        const handle = await this.getHandle(path);
+        if (handle instanceof FileSystemFileHandle) {
+            const file = await handle.getFile();
+            const buffer = await file.arrayBuffer();
+            return this.newFile(path, flags, buffer, file.size, file.lastModified);
+        }
+    }
+    async unlink(path, cred) {
+        const handle = await this.getHandle(dirname(path));
+        if (handle instanceof FileSystemDirectoryHandle) {
             try {
-                for (var _e = true, _f = __asyncValues(handle.keys()), _g; _g = yield _f.next(), _b = _g.done, !_b; _e = true) {
-                    _d = _g.value;
-                    _e = false;
-                    const key = _d;
-                    _keys.push(join(path, key));
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_e && !_b && (_c = _f.return)) yield _c.call(_f);
-                }
-                finally { if (e_1) throw e_1.error; }
+                await handle.removeEntry(basename(path), { recursive: true });
             }
-            return _keys;
-        });
+            catch (e) {
+                handleError(path, e);
+            }
+        }
+    }
+    async rmdir(path, cred) {
+        return this.unlink(path, cred);
+    }
+    async mkdir(p, mode, cred) {
+        const overwrite = mode && mode.flag && mode.flag.includes('w') && !mode.flag.includes('x');
+        const existingHandle = await this.getHandle(p);
+        if (existingHandle && !overwrite) {
+            throw ApiError.EEXIST(p);
+        }
+        const handle = await this.getHandle(dirname(p));
+        if (handle instanceof FileSystemDirectoryHandle) {
+            await handle.getDirectoryHandle(basename(p), { create: true });
+        }
+    }
+    async readdir(path, cred) {
+        const handle = await this.getHandle(path);
+        if (!(handle instanceof FileSystemDirectoryHandle)) {
+            throw ApiError.ENOTDIR(path);
+        }
+        const _keys = [];
+        for await (const key of handle.keys()) {
+            _keys.push(join(path, key));
+        }
+        return _keys;
     }
     newFile(path, flag, data, size, lastModified) {
         return new FileSystemAccessFile(this, path, flag, new Stats(FileType.FILE, size || 0, undefined, undefined, lastModified || new Date().getTime()), new Uint8Array(data));
     }
-    getHandle(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._handles.has(path)) {
-                return this._handles.get(path);
-            }
-            let walkedPath = '/';
-            const [, ...pathParts] = path.split('/');
-            const getHandleParts = ([pathPart, ...remainingPathParts]) => __awaiter(this, void 0, void 0, function* () {
-                const walkingPath = join(walkedPath, pathPart);
-                const continueWalk = (handle) => {
-                    walkedPath = walkingPath;
-                    this._handles.set(walkedPath, handle);
-                    if (remainingPathParts.length === 0) {
-                        return this._handles.get(path);
-                    }
-                    getHandleParts(remainingPathParts);
-                };
-                const handle = this._handles.get(walkedPath);
-                try {
-                    return yield continueWalk(yield handle.getDirectoryHandle(pathPart));
+    async getHandle(path) {
+        if (this._handles.has(path)) {
+            return this._handles.get(path);
+        }
+        let walkedPath = '/';
+        const [, ...pathParts] = path.split('/');
+        const getHandleParts = async ([pathPart, ...remainingPathParts]) => {
+            const walkingPath = join(walkedPath, pathPart);
+            const continueWalk = (handle) => {
+                walkedPath = walkingPath;
+                this._handles.set(walkedPath, handle);
+                if (remainingPathParts.length === 0) {
+                    return this._handles.get(path);
                 }
-                catch (error) {
-                    if (error.name === 'TypeMismatchError') {
-                        try {
-                            return yield continueWalk(yield handle.getFileHandle(pathPart));
-                        }
-                        catch (err) {
-                            handleError(walkingPath, err);
-                        }
-                    }
-                    else if (error.message === 'Name is not allowed.') {
-                        throw new ApiError(ErrorCode.ENOENT, error.message, walkingPath);
+                getHandleParts(remainingPathParts);
+            };
+            const handle = this._handles.get(walkedPath);
+            try {
+                return await continueWalk(await handle.getDirectoryHandle(pathPart));
+            }
+            catch (error) {
+                if (error.name === 'TypeMismatchError') {
+                    try {
+                        return await continueWalk(await handle.getFileHandle(pathPart));
                     }
-                    else {
-                        handleError(walkingPath, error);
+                    catch (err) {
+                        handleError(walkingPath, err);
                     }
                 }
-            });
-            yield getHandleParts(pathParts);
-        });
+                else if (error.message === 'Name is not allowed.') {
+                    throw new ApiError(ErrorCode.ENOENT, error.message, walkingPath);
+                }
+                else {
+                    handleError(walkingPath, error);
+                }
+            }
+        };
+        await getHandleParts(pathParts);
     }
 }
 _a = FileSystemAccessFileSystem;

package/dist/backends/HTTPRequest.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import { BaseFileSystem, FileContents, FileSystemMetadata } from '@zenfs/core/filesystem.js';
+import { BaseFileSystem, FileSystemMetadata } from '@zenfs/core/filesystem.js';
 import { FileFlag, NoSyncFile } from '@zenfs/core/file.js';
 import { Stats } from '@zenfs/core/stats.js';
 import { Cred } from '@zenfs/core/cred.js';
@@ -63,8 +62,8 @@ export declare class HTTPRequest extends BaseFileSystem {
     empty(): void;
     /**
      * Special HTTPFS function: Preload the given file into the index.
-     * @param [String] path
-     * @param [ZenFS.Uint8Array] buffer
+     * @param path
+     * @param buffer
      */
     preloadFile(path: string, buffer: Uint8Array): void;
     stat(path: string, cred: Cred): Promise<Stats>;
@@ -73,7 +72,7 @@ export declare class HTTPRequest extends BaseFileSystem {
     /**
      * We have the entire file as a buffer; optimize readFile.
      */
-    readFile(fname: string, encoding: BufferEncoding, flag: FileFlag, cred: Cred): Promise<FileContents>;
+    readFile(fname: string, flag: FileFlag, cred: Cred): Promise<Uint8Array>;
     private _getHTTPPath;
     /**
      * Asynchronously download the given file.

package/dist/backends/HTTPRequest.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var _a;
 import { BaseFileSystem } from '@zenfs/core/filesystem.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
@@ -16,7 +7,6 @@ import { fetchIsAvailable, fetchFile, fetchFileSize } from '../fetch.js';
 import { FileIndex, isIndexFileInode, isIndexDirInode } from '@zenfs/core/FileIndex.js';
 import { CreateBackend } from '@zenfs/core/backends/backend.js';
 import { R_OK } from '@zenfs/core/emulation/constants.js';
-import { decode } from '@zenfs/core/utils.js';
 /**
  * A simple filesystem backed by HTTP downloads. You must create a directory listing using the
  * `make_http_index` tool provided by ZenFS.
@@ -66,7 +56,11 @@ export class HTTPRequest extends BaseFileSystem {
         this.prefixUrl = baseUrl;
     }
     get metadata() {
-        return Object.assign(Object.assign({}, super.metadata), { name: _a.Name, readonly: true });
+        return {
+            ...super.metadata,
+            name: _a.Name,
+            readonly: true,
+        };
     }
     empty() {
         this._index.fileIterator(function (file) {
@@ -75,8 +69,8 @@ export class HTTPRequest extends BaseFileSystem {
     }
     /**
      * Special HTTPFS function: Preload the given file into the index.
-     * @param [String] path
-     * @param [ZenFS.Uint8Array] buffer
+     * @param path
+     * @param buffer
      */
     preloadFile(path, buffer) {
         const inode = this._index.getInode(path);
@@ -92,98 +86,88 @@ export class HTTPRequest extends BaseFileSystem {
             throw ApiError.EISDIR(path);
         }
     }
-    stat(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inode = this._index.getInode(path);
-            if (inode === null) {
-                throw ApiError.ENOENT(path);
-            }
-            if (!inode.toStats().hasAccess(R_OK, cred)) {
-                throw ApiError.EACCES(path);
-            }
-            let stats;
-            if (isIndexFileInode(inode)) {
-                stats = inode.getData();
-                // At this point, a non-opened file will still have default stats from the listing.
-                if (stats.size < 0) {
-                    stats.size = yield this._requestFileSize(path);
-                }
-            }
-            else if (isIndexDirInode(inode)) {
-                stats = inode.getStats();
-            }
-            else {
-                throw ApiError.FileError(ErrorCode.EINVAL, path);
+    async stat(path, cred) {
+        const inode = this._index.getInode(path);
+        if (inode === null) {
+            throw ApiError.ENOENT(path);
+        }
+        if (!inode.toStats().hasAccess(R_OK, cred)) {
+            throw ApiError.EACCES(path);
+        }
+        let stats;
+        if (isIndexFileInode(inode)) {
+            stats = inode.getData();
+            // At this point, a non-opened file will still have default stats from the listing.
+            if (stats.size < 0) {
+                stats.size = await this._requestFileSize(path);
             }
-            return stats;
-        });
+        }
+        else if (isIndexDirInode(inode)) {
+            stats = inode.getStats();
+        }
+        else {
+            throw ApiError.FileError(ErrorCode.EINVAL, path);
+        }
+        return stats;
     }
-    open(path, flags, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // INVARIANT: You can't write to files on this file system.
-            if (flags.isWriteable()) {
-                throw new ApiError(ErrorCode.EPERM, path);
-            }
-            // Check if the path exists, and is a file.
-            const inode = this._index.getInode(path);
-            if (inode === null) {
-                throw ApiError.ENOENT(path);
-            }
-            if (!inode.toStats().hasAccess(flags.getMode(), cred)) {
-                throw ApiError.EACCES(path);
-            }
-            if (isIndexFileInode(inode) || isIndexDirInode(inode)) {
-                switch (flags.pathExistsAction()) {
-                    case ActionType.THROW_EXCEPTION:
-                    case ActionType.TRUNCATE_FILE:
-                        throw ApiError.EEXIST(path);
-                    case ActionType.NOP:
-                        if (isIndexDirInode(inode)) {
-                            const stats = inode.getStats();
-                            return new NoSyncFile(this, path, flags, stats, stats.fileData || undefined);
-                        }
-                        const stats = inode.getData();
-                        // Use existing file contents.
-                        // XXX: Uh, this maintains the previously-used flag.
-                        if (stats.fileData) {
-                            return new NoSyncFile(this, path, flags, Stats.clone(stats), stats.fileData);
-                        }
-                        // @todo be lazier about actually requesting the file
-                        const buffer = yield this._requestFile(path, 'buffer');
-                        // we don't initially have file sizes
-                        stats.size = buffer.length;
-                        stats.fileData = buffer;
-                        return new NoSyncFile(this, path, flags, Stats.clone(stats), buffer);
-                    default:
-                        throw new ApiError(ErrorCode.EINVAL, 'Invalid FileMode object.');
-                }
-            }
-            else {
-                throw ApiError.EPERM(path);
+    async open(path, flags, mode, cred) {
+        // INVARIANT: You can't write to files on this file system.
+        if (flags.isWriteable()) {
+            throw new ApiError(ErrorCode.EPERM, path);
+        }
+        // Check if the path exists, and is a file.
+        const inode = this._index.getInode(path);
+        if (inode === null) {
+            throw ApiError.ENOENT(path);
+        }
+        if (!inode.toStats().hasAccess(flags.getMode(), cred)) {
+            throw ApiError.EACCES(path);
+        }
+        if (isIndexFileInode(inode) || isIndexDirInode(inode)) {
+            switch (flags.pathExistsAction()) {
+                case ActionType.THROW_EXCEPTION:
+                case ActionType.TRUNCATE_FILE:
+                    throw ApiError.EEXIST(path);
+                case ActionType.NOP:
+                    if (isIndexDirInode(inode)) {
+                        const stats = inode.getStats();
+                        return new NoSyncFile(this, path, flags, stats, stats.fileData || undefined);
+                    }
+                    const stats = inode.getData();
+                    // Use existing file contents.
+                    // XXX: Uh, this maintains the previously-used flag.
+                    if (stats.fileData) {
+                        return new NoSyncFile(this, path, flags, Stats.clone(stats), stats.fileData);
+                    }
+                    // @todo be lazier about actually requesting the file
+                    const buffer = await this._requestFile(path, 'buffer');
+                    // we don't initially have file sizes
+                    stats.size = buffer.length;
+                    stats.fileData = buffer;
+                    return new NoSyncFile(this, path, flags, Stats.clone(stats), buffer);
+                default:
+                    throw new ApiError(ErrorCode.EINVAL, 'Invalid FileMode object.');
             }
-        });
+        }
+        else {
+            throw ApiError.EPERM(path);
+        }
     }
-    readdir(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.readdirSync(path, cred);
-        });
+    async readdir(path, cred) {
+        return this.readdirSync(path, cred);
     }
     /**
      * We have the entire file as a buffer; optimize readFile.
      */
-    readFile(fname, encoding, flag, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Get file.
-            const fd = yield this.open(fname, flag, 0o644, cred);
-            try {
-                const fdCast = fd;
-                const fdBuff = fdCast.getBuffer();
-                return encoding ? decode(fdBuff) : fdBuff;
-            }
-            finally {
-                yield fd.close();
-            }
-        });
+    async readFile(fname, flag, cred) {
+        // Get file.
+        const fd = await this.open(fname, flag, 0o644, cred);
+        try {
+            return fd.getBuffer();
+        }
+        finally {
+            await fd.close();
+        }
     }
     _getHTTPPath(filePath) {
         if (filePath.charAt(0) === '/') {