@utoo/web 1.3.0-rc.2 → 1.3.1

package/esm/threadWorker.js

@@ -1,4 +1,4 @@
-import initWasm from "./utoo";
+import { initSync } from "./utoo";
 // this is for wasm_thread to spawn new worker thread.
-// see: https://github.com/utooland/wasm_thread/blob/94438ff771ee0a6a55d79e49a655707970acb615/src/wasm32/js/web_worker.js#L10
-self.wasm_bindgen = initWasm;
+// https://github.com/utooland/wasm_thread/blob/fd53c2f5a20e9f899d9216dee045472f50d97219/src/wasm32/js/web_worker.sync.js#L10
+self.wasm_bindgen = initSync;

package/esm/utoo/index.js

@@ -1274,7 +1274,7 @@ function __wbg_get_imports(memory) {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_3247(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_3253(a, state0.b, arg0, arg1);
                     }
                     finally {
                         state0.a = a;
@@ -1594,33 +1594,33 @@ function __wbg_get_imports(memory) {
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [Externref], shim_idx: 7400, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22596, __wasm_bindgen_func_elem_83828);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [Externref], shim_idx: 7399, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22582, __wasm_bindgen_func_elem_83799);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 7384, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
-            const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22596, __wasm_bindgen_func_elem_83390);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 7383, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22582, __wasm_bindgen_func_elem_83364);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 7400, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22596, __wasm_bindgen_func_elem_83828);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 7399, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22582, __wasm_bindgen_func_elem_83799);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function (arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [], shim_idx: 1846, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22596, __wasm_bindgen_func_elem_22597);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22582, __wasm_bindgen_func_elem_22583);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 7404, function: Function { arguments: [Ref(NamedExternref("MessageEvent"))], shim_idx: 7405, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_83880, __wasm_bindgen_func_elem_83881);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 7403, function: Function { arguments: [Ref(NamedExternref("MessageEvent"))], shim_idx: 7404, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_83851, __wasm_bindgen_func_elem_83852);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000006: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 7404, function: Function { arguments: [], shim_idx: 1846, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_83880, __wasm_bindgen_func_elem_22597);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 7403, function: Function { arguments: [], shim_idx: 1846, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_83851, __wasm_bindgen_func_elem_22583);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000007: function (arg0) {
@@ -1668,25 +1668,25 @@ function __wbg_get_imports(memory) {
         "./index_bg.js": import0,
     };
 }
-function __wasm_bindgen_func_elem_22597(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_22597(arg0, arg1);
+function __wasm_bindgen_func_elem_22583(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_22583(arg0, arg1);
 }
-function __wasm_bindgen_func_elem_83828(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_83828(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_83799(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_83799(arg0, arg1, addHeapObject(arg2));
 }
-function __wasm_bindgen_func_elem_83390(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_83390(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_83364(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_83364(arg0, arg1, addHeapObject(arg2));
 }
-function __wasm_bindgen_func_elem_83881(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_83852(arg0, arg1, arg2) {
     try {
-        wasm.__wasm_bindgen_func_elem_83881(arg0, arg1, addBorrowedObject(arg2));
+        wasm.__wasm_bindgen_func_elem_83852(arg0, arg1, addBorrowedObject(arg2));
     }
     finally {
         heap[stack_pointer++] = undefined;
     }
 }
-function __wasm_bindgen_func_elem_3247(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_3247(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_3253(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_3253(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 const __wbindgen_enum_DirEntryType = ["file", "directory"];
 const __wbindgen_enum_FileSystemChangeRecordType = ["appeared", "disappeared", "errored", "modified", "moved", "unknown"];

package/esm/webpackLoaders/polyfills/{fsPromisesPolyfill.d.ts → fsPolyfill/promises.d.ts}

@@ -1,4 +1,4 @@
-import { Stats } from "../../types";
+import { Stats } from "../../../types";
 export declare const promises: {
     readFile: (p: string, options?: any) => Promise<any>;
     writeFile: (p: string, data: string | Uint8Array, options?: any) => Promise<void>;

package/esm/webpackLoaders/polyfills/fsPolyfill/promises.js

@@ -0,0 +1,159 @@
+import { Buffer } from "buffer";
+import { Stats } from "../../../types";
+import { getFs, resolvePath, translateError } from "./utils";
+export const promises = {
+    readFile: async (p, options) => {
+        const encoding = options === "utf8" ||
+            options === "utf-8" ||
+            (options === null || options === void 0 ? void 0 : options.encoding) === "utf8" ||
+            (options === null || options === void 0 ? void 0 : options.encoding) === "utf-8"
+            ? "utf8"
+            : undefined;
+        const fs = getFs();
+        const resolvedPath = resolvePath(p);
+        try {
+            const data = await (encoding
+                ? fs.readToString(resolvedPath)
+                : fs.read(resolvedPath));
+            return encoding ? data : Buffer.from(data);
+        }
+        catch (e) {
+            throw translateError(e, p, "open");
+        }
+    },
+    writeFile: async (p, data, options) => {
+        const fs = getFs();
+        const resolvedPath = resolvePath(p);
+        try {
+            if (typeof data === "string") {
+                await fs.writeString(resolvedPath, data);
+            }
+            else {
+                await fs.write(resolvedPath, data);
+            }
+        }
+        catch (e) {
+            throw translateError(e, p, "open");
+        }
+    },
+    readdir: async (p, options) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            const entries = await getFs().readDir(resolvedPath);
+            return entries.map((e) => {
+                const json = e.toJSON();
+                if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
+                    return {
+                        name: json.name,
+                        isFile: () => json.type === "file",
+                        isDirectory: () => json.type === "directory",
+                        isSymbolicLink: () => false,
+                    };
+                }
+                return json.name;
+            });
+        }
+        catch (e) {
+            throw translateError(e, p, "scandir");
+        }
+    },
+    mkdir: async (p, options) => {
+        const fs = getFs();
+        const resolvedPath = resolvePath(p);
+        try {
+            if (options === null || options === void 0 ? void 0 : options.recursive) {
+                await fs.createDirAll(resolvedPath);
+            }
+            else {
+                await fs.createDir(resolvedPath);
+            }
+        }
+        catch (e) {
+            throw translateError(e, p, "mkdir");
+        }
+    },
+    rm: async (p, options) => {
+        const fs = getFs();
+        const resolvedPath = resolvePath(p);
+        try {
+            const metadata = await fs.metadata(resolvedPath);
+            const type = metadata.toJSON().type;
+            if (type === "file") {
+                await fs.removeFile(resolvedPath);
+            }
+            else {
+                await fs.removeDir(resolvedPath, !!(options === null || options === void 0 ? void 0 : options.recursive));
+            }
+        }
+        catch (e) {
+            throw translateError(e, p, "rm");
+        }
+    },
+    rmdir: async (p, options) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            return await getFs().removeDir(resolvedPath, !!(options === null || options === void 0 ? void 0 : options.recursive));
+        }
+        catch (e) {
+            throw translateError(e, p, "rmdir");
+        }
+    },
+    copyFile: async (src, dst) => {
+        try {
+            return await getFs().copyFile(resolvePath(src), resolvePath(dst));
+        }
+        catch (e) {
+            throw translateError(e, src, "copyfile");
+        }
+    },
+    stat: async (p) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            const metadata = await getFs().metadata(resolvedPath);
+            const json = metadata.toJSON();
+            return new Stats({
+                type: json.type,
+                size: Number(json.file_size || 0),
+            });
+        }
+        catch (e) {
+            throw translateError(e, p, "stat");
+        }
+    },
+    lstat: async (p) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            const metadata = await getFs().metadata(resolvedPath);
+            const json = metadata.toJSON();
+            return new Stats({
+                type: json.type,
+                size: Number(json.file_size || 0),
+            });
+        }
+        catch (e) {
+            throw translateError(e, p, "lstat");
+        }
+    },
+    realpath: async (p) => p,
+    access: async (p, mode) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            await getFs().metadata(resolvedPath);
+        }
+        catch (e) {
+            throw translateError(e, p, "access");
+        }
+    },
+};
+export const readFile = promises.readFile;
+export const writeFile = promises.writeFile;
+export const readdir = promises.readdir;
+export const mkdir = promises.mkdir;
+export const rm = promises.rm;
+export const rmdir = promises.rmdir;
+export const copyFile = promises.copyFile;
+export const stat = promises.stat;
+export const lstat = promises.lstat;
+export const realpath = promises.realpath;
+export const access = promises.access;
+export default promises;

package/esm/webpackLoaders/polyfills/{fsPolyfill.d.ts → fsPolyfill/sync.d.ts}

@@ -1,6 +1,6 @@
 import { Buffer } from "buffer";
-import { Stats } from "../../types";
-import { promises } from "./fsPromisesPolyfill";
+import { Stats } from "../../../types";
+import { promises } from "./promises";
 export declare function readFileSync(path: string, options: any): string | Buffer<any>;
 export declare function readdirSync(path: string, options?: any): any;
 export declare function writeFileSync(path: string, data: string | Uint8Array, options?: any): void;
@@ -11,7 +11,7 @@ export declare function copyFileSync(src: string, dst: string): void;
 export declare function statSync(p: string): Stats;
 export declare function lstatSync(p: string): Stats;
 export declare function realpathSync(p: string): string;
-export declare function accessSync(path: string, mode?: number): void;
+export declare function accessSync(p: string, mode?: number): void;
 export declare function existsSync(path: string): boolean;
 export declare function readFile(path: string, options: any, cb: Function): void;
 export declare function readdir(path: string, options: any, cb: Function): void;

package/esm/webpackLoaders/polyfills/fsPolyfill/sync.js

@@ -0,0 +1,384 @@
+import { Buffer } from "buffer";
+import { Stats } from "../../../types";
+import { promises } from "./promises";
+import { getFs, resolvePath, translateError } from "./utils";
+// --- Synchronous API (via WASM Project Sync APIs) ---
+const textDecoder = new TextDecoder();
+export function readFileSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const result = fs.readSync(resolvedPath);
+        if (options === "utf8" ||
+            options === "utf-8" ||
+            (options && (options.encoding === "utf8" || options.encoding === "utf-8"))) {
+            return textDecoder.decode(result);
+        }
+        return Buffer.from(result);
+    }
+    catch (e) {
+        throw translateError(e, path, "open");
+    }
+}
+export function readdirSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const entries = fs.readDirSync(resolvedPath);
+        if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
+            return entries.map((e) => ({
+                name: e.name,
+                isFile: () => e.type === "file",
+                isDirectory: () => e.type === "directory",
+                isSymbolicLink: () => false,
+            }));
+        }
+        return entries.map((e) => e.name);
+    }
+    catch (e) {
+        throw translateError(e, path, "scandir");
+    }
+}
+export function writeFileSync(path, data, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        let content;
+        if (typeof data === "string") {
+            content = new TextEncoder().encode(data);
+        }
+        else {
+            content = data;
+        }
+        fs.writeSync(resolvedPath, content);
+    }
+    catch (e) {
+        throw translateError(e, path, "open");
+    }
+}
+export function mkdirSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
+        if (recursive) {
+            fs.createDirAllSync(resolvedPath);
+        }
+        else {
+            fs.createDirSync(resolvedPath);
+        }
+    }
+    catch (e) {
+        throw translateError(e, path, "mkdir");
+    }
+}
+export function rmSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
+        if (recursive) {
+            fs.removeDirSync(resolvedPath, true);
+        }
+        else {
+            fs.removeFileSync(resolvedPath);
+        }
+    }
+    catch (e) {
+        throw translateError(e, path, "rm");
+    }
+}
+export function rmdirSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
+        fs.removeDirSync(resolvedPath, recursive);
+    }
+    catch (e) {
+        throw translateError(e, path, "rmdir");
+    }
+}
+export function copyFileSync(src, dst) {
+    const fs = getFs();
+    try {
+        fs.copyFileSync(resolvePath(src), resolvePath(dst));
+    }
+    catch (e) {
+        throw translateError(e, src, "copyfile");
+    }
+}
+export function statSync(p) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(p);
+    try {
+        const metadata = fs.metadataSync(resolvedPath);
+        let type, size;
+        // @ts-ignore
+        if (typeof metadata.toJSON === "function") {
+            // @ts-ignore
+            const json = metadata.toJSON();
+            type = json.type;
+            size = json.file_size;
+        }
+        else {
+            // @ts-ignore
+            type = metadata.type;
+            // @ts-ignore
+            size = metadata.file_size;
+        }
+        return new Stats({
+            type: type === "directory" ? "directory" : "file",
+            size: Number(size || 0),
+            atimeMs: Date.now(),
+            mtimeMs: Date.now(),
+            ctimeMs: Date.now(),
+            birthtimeMs: Date.now(),
+        });
+    }
+    catch (e) {
+        throw translateError(e, p, "stat");
+    }
+}
+export function lstatSync(p) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(p);
+    try {
+        const metadata = fs.metadataSync(resolvedPath);
+        let type, size;
+        // @ts-ignore
+        if (typeof metadata.toJSON === "function") {
+            // @ts-ignore
+            const json = metadata.toJSON();
+            type = json.type;
+            size = json.file_size;
+        }
+        else {
+            // @ts-ignore
+            type = metadata.type;
+            // @ts-ignore
+            size = metadata.file_size;
+        }
+        return new Stats({
+            type: type === "directory" ? "directory" : "file",
+            size: Number(size || 0),
+            atimeMs: Date.now(),
+            mtimeMs: Date.now(),
+            ctimeMs: Date.now(),
+            birthtimeMs: Date.now(),
+        });
+    }
+    catch (e) {
+        throw translateError(e, p, "lstat");
+    }
+}
+export function realpathSync(p) {
+    return p;
+}
+export function accessSync(p, mode) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(p);
+    try {
+        fs.metadataSync(resolvedPath);
+    }
+    catch (e) {
+        throw translateError(e, p, "access");
+    }
+}
+export function existsSync(path) {
+    try {
+        statSync(path);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+// --- Asynchronous API (via WASM Project) ---
+export function readFile(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const encoding = options === "utf8" ||
+        options === "utf-8" ||
+        (options === null || options === void 0 ? void 0 : options.encoding) === "utf8" ||
+        (options === null || options === void 0 ? void 0 : options.encoding) === "utf-8"
+        ? "utf8"
+        : undefined;
+    const resolvedPath = resolvePath(path);
+    const fs = getFs();
+    const promise = encoding
+        ? fs.readToString(resolvedPath)
+        : fs.read(resolvedPath);
+    promise
+        .then((data) => {
+        cb(null, encoding ? data : Buffer.from(data));
+    })
+        .catch((e) => cb(translateError(e, path, "open")));
+}
+export function readdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    getFs()
+        .readDir(resolvePath(path))
+        .then((entries) => {
+        const result = entries.map((e) => {
+            const json = e.toJSON();
+            if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
+                return {
+                    name: json.name,
+                    isFile: () => json.type === "file",
+                    isDirectory: () => json.type === "directory",
+                    isSymbolicLink: () => false,
+                };
+            }
+            return json.name;
+        });
+        cb(null, result);
+    })
+        .catch((e) => cb(translateError(e, path, "scandir")));
+}
+export function writeFile(path, data, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const resolvedPath = resolvePath(path);
+    const fs = getFs();
+    const promise = typeof data === "string"
+        ? fs.writeString(resolvedPath, data)
+        : fs.write(resolvedPath, data);
+    promise
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, path, "open")));
+}
+export function mkdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const resolvedPath = resolvePath(path);
+    const fs = getFs();
+    const promise = (options === null || options === void 0 ? void 0 : options.recursive)
+        ? fs.createDirAll(resolvedPath)
+        : fs.createDir(resolvedPath);
+    promise
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, path, "mkdir")));
+}
+export function rm(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const resolvedPath = resolvePath(path);
+    const fs = getFs();
+    fs.metadata(resolvedPath)
+        .then((metadata) => {
+        const type = metadata.toJSON().type;
+        if (type === "file") {
+            return fs.removeFile(resolvedPath);
+        }
+        else {
+            return fs.removeDir(resolvedPath, !!(options === null || options === void 0 ? void 0 : options.recursive));
+        }
+    })
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, path, "rm")));
+}
+export function rmdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    getFs()
+        .removeDir(resolvePath(path), !!(options === null || options === void 0 ? void 0 : options.recursive))
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, path, "rmdir")));
+}
+export function copyFile(src, dst, cb) {
+    getFs()
+        .copyFile(resolvePath(src), resolvePath(dst))
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, src, "copyfile")));
+}
+export function stat(p, cb) {
+    getFs()
+        .metadata(resolvePath(p))
+        .then((metadata) => {
+        const json = metadata.toJSON();
+        cb(null, new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        }));
+    })
+        .catch((e) => cb(translateError(e, p, "stat")));
+}
+export function lstat(p, cb) {
+    getFs()
+        .metadata(resolvePath(p))
+        .then((metadata) => {
+        const json = metadata.toJSON();
+        cb(null, new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        }));
+    })
+        .catch((e) => cb(translateError(e, p, "lstat")));
+}
+export function realpath(p, cb) {
+    cb(null, p);
+}
+export function access(p, mode, cb) {
+    if (typeof mode === "function") {
+        cb = mode;
+        mode = 0;
+    }
+    getFs()
+        .metadata(resolvePath(p))
+        .then(() => {
+        if (cb)
+            cb(null);
+    })
+        .catch((e) => {
+        if (cb)
+            cb(translateError(e, p, "access"));
+    });
+}
+export const constants = {
+    F_OK: 0,
+    R_OK: 4,
+    W_OK: 2,
+    X_OK: 1,
+};
+export default {
+    readFile,
+    readFileSync,
+    readdir,
+    readdirSync,
+    writeFile,
+    writeFileSync,
+    mkdir,
+    mkdirSync,
+    rm,
+    rmSync,
+    rmdir,
+    rmdirSync,
+    copyFile,
+    copyFileSync,
+    stat,
+    statSync,
+    lstat,
+    lstatSync,
+    realpath,
+    realpathSync,
+    access,
+    accessSync,
+    existsSync,
+    promises,
+    constants,
+};
+export { promises };

package/esm/webpackLoaders/polyfills/fsPolyfill/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function resolvePath(p: string): string;
+export declare function getFs(): any;
+export declare function translateError(error: any, path: string, syscall: string): any;