functionalscript 0.9.1 → 0.9.2

package/djs/parser-new/test.f.js

@@ -0,0 +1,201 @@
+import { descentParser } from "../../bnf/data/module.f.js";
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
+import { jsGrammar } from "./module.f.js";
+const mapCodePoint = (cp) => [cp, undefined];
+const descentParserCpOnly = (m, name, cp) => {
+    const cpm = toArray(map(mapCodePoint)(cp));
+    return m(name, cpm);
+};
+export default {
+    isValid: [() => {
+            const m = descentParser(jsGrammar());
+            const expect = (s, expected) => {
+                const cp = toArray(stringToCodePointList(s));
+                const mr = descentParserCpOnly(m, '', cp);
+                const success = mr[1] && mr[2] === cp.length;
+                if (success !== expected) {
+                    throw mr;
+                }
+            };
+            expect('   true   ', true);
+            expect('   tr2ue   ', true);
+            expect('   2true   ', true);
+            expect('   true"   ', false);
+            expect('   "Hello"   ', true);
+            expect('   "Hello   ', false);
+            expect('   "Hello\\n\\r\\""   ', true);
+            expect('   56.7e+5  ', true);
+            expect('   -56.7e+5  ', true);
+            expect('   h-56.7e+5   ', true);
+            expect('   -56.7e+5   3', true);
+            expect('   [] ', true);
+            expect('   {} ', true);
+            expect('   [[[]]] ', true);
+            expect('   [1] ', true);
+            expect('   [ 12, false, "a"]  ', true);
+            expect('   [ 12, false2, "a"]  ', true);
+            expect('   { "q": [ 12, false, [{"b" : "c"}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [}], "a"] }  ', true);
+            expect('   [{ "q": [ 12, false, [{}], "a"] }]  ', true);
+            expect('   [{ "q": [ 12, false, [}], "a"] }]  ', true);
+            expect('. + ++ +=', true);
+            expect('//12\n', true);
+            expect('/*12*/', true);
+            expect('/* 1*2 */', true);
+        }
+    ],
+    parser: [
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('tr'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'id')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('"tr"'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'string')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('56.7e+5'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'number')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('56n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'number')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('*'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '*')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('**'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '**')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('=>'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '=>')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('=='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '==')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('==='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '===')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '=')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList(' '));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== ' ')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '\n')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('/\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '/')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('//\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'comment')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('/*1*/'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'comment')
+                throw JSON.stringify(mr);
+        }
+    ]
+};

package/djs/serializer/module.f.js

@@ -53,9 +53,9 @@ export const serializeWithoutConst = sort => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         switch (typeof value) {
@@ -96,9 +96,9 @@ const serializeWithConst = sort => refs => root => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         if (value !== root) {

package/fjs/module.f.d.ts

@@ -1,2 +1,2 @@
-import type { Io } from '../io/module.f.ts';
+import { type Io } from '../io/module.f.ts';
 export declare const main: (io: Io) => Promise<number>;

package/fjs/module.f.js

@@ -1,5 +1,7 @@
+import { fromIo } from "../io/module.f.js";
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../dev/tf/module.f.js";
+import { main as casMain } from "../cas/module.f.js";
 export const main = (io) => {
     const { error } = io.console;
     const [command, ...rest] = io.process.argv.slice(2);
@@ -12,8 +14,7 @@ export const main = (io) => {
             return compile(io)(rest);
         case 'cas':
         case 's':
-            error('cas command is not implemented yet');
-            return Promise.resolve(1);
+            return fromIo(io)(casMain(rest));
         case undefined:
             error('Error: command is required');
             return Promise.resolve(1);

package/fsc/module.f.js

@@ -26,7 +26,7 @@ const reduce = (a) => {
     return toArray(listReduce(merge)(empty)(a));
 };
 const codePointRange = fromRange(def);
-const range = fn(asciiRange).then(codePointRange).result;
+const range = fn(asciiRange).map(codePointRange).result;
 const rangeSet = (l) => (f) => {
     const codePointRange = fromRange(def);
     const g = r => codePointRange(asciiRange(r))(f);

package/io/module.d.ts

@@ -1,4 +1,8 @@
 import { type Io, type Run } from './module.f.ts';
+import type { NodeProgram } from '../types/effect/node/module.f.ts';
 export declare const io: Io;
 declare const runDefault: Run;
 export default runDefault;
+export type NodeRun = (p: NodeProgram) => Promise<number>;
+export declare const ioRun: (io: Io) => NodeRun;
+export declare const nodeRun: NodeRun;

package/io/module.f.d.ts

@@ -1,10 +1,12 @@
-import type { Result } from '../types/result/module.f.ts';
+import type { NodeEffect } from '../types/effect/node/module.f.ts';
+import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
  * @see https://nodejs.org/api/fs.html#class-fsdirent
  */
 export type Dirent = {
     readonly name: string;
+    readonly parentPath: string;
     readonly isDirectory: () => boolean;
     readonly isFile: () => boolean;
 };
@@ -15,6 +17,11 @@ export type RmOptions = {
 export type MakeDirectoryOptions = {
     readonly recursive?: boolean;
 };
+export type ReadDir = ((path: string, options: {
+    withFileTypes: true;
+}) => Promise<Dirent[]>) & ((path: string, options: {
+    recursive?: true;
+}) => Promise<readonly string[]>);
 /**
  * File system operations interface
  * @see https://nodejs.org/api/fs.html
@@ -27,9 +34,7 @@ export type Fs = {
     readonly promises: {
         readonly readFile: (path: string) => Promise<Uint8Array>;
         readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
-        readonly readdir: (path: string, options: {
-            withFileTypes: true;
-        }) => Promise<Dirent[]>;
+        readonly readdir: ReadDir;
         readonly rm: (path: string, options?: RmOptions) => Promise<void>;
         readonly mkdir: (path: string, options?: MakeDirectoryOptions) => Promise<string | undefined>;
         readonly copyFile: (src: string, dest: string) => Promise<void>;
@@ -99,3 +104,4 @@ export type Run = (f: App) => Promise<never>;
  * Handles errors by exiting with code 1
  */
 export declare const run: (io: Io) => Run;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, }: Io) => <T>(effect: NodeEffect<T>) => Promise<T>;

package/io/module.f.js

@@ -1,3 +1,7 @@
+import { normalize } from "../path/module.f.js";
+import { asyncRun } from "../types/effect/module.js";
+import { error, ok } from "../types/result/module.f.js";
+import { fromVec, toVec } from "../types/uint8array/module.f.js";
 /**
  * Runs a function and exits the process with the returned code
  * Handles errors by exiting with code 1
@@ -14,3 +18,20 @@ export const run = (io) => {
     };
     return async (f) => io.process.exit(code(await io.asyncTryCatch(() => f(io))));
 };
+const tc = async (f) => {
+    try {
+        return ok(await f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, }) => asyncRun({
+    error: async (message) => error(message),
+    log: async (message) => log(message),
+    mkdir: param => tc(async () => { await mkdir(...param); }),
+    readFile: path => tc(async () => toVec(await readFile(path))),
+    readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
+        .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
+    writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
+});

package/io/module.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { run } from "./module.f.js";
+import { fromIo, run } from "./module.f.js";
 import fs from 'node:fs';
 import process from "node:process";
 import { concat } from "../path/module.f.js";
@@ -41,3 +41,9 @@ export const io = {
 };
 const runDefault = run(io);
 export default runDefault;
+export const ioRun = (io) => {
+    const r = fromIo(io);
+    const { argv } = io.process;
+    return p => r(p(argv));
+};
+export const nodeRun = ioRun(io);

package/json/module.f.js

@@ -25,9 +25,9 @@ export const serialize = sort => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         switch (typeof value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "type": "module",
   "files": [
     "**/*.js",
@@ -15,7 +15,8 @@
     "fst": "node ./fjs/module.ts t",
     "fjs": "node ./fjs/module.ts",
     "ci-update": "node ./ci/module.ts",
-    "update": "git clean -fdx && npm install && npm run index && npm run ci-update"
+    "update": "git clean -fdx && npm install && npm run index && npm run ci-update",
+    "website": "node --experimental-strip-types ./website/module.ts"
   },
   "engines": {
     "node": ">=20"

package/path/module.f.d.ts

@@ -1,3 +1,4 @@
 import type { Reduce, Unary } from "../types/function/operator/module.f.ts";
+export declare const parse: (path: string) => readonly string[];
 export declare const normalize: Unary<string, string>;
 export declare const concat: Reduce<string>;

package/path/module.f.js

@@ -1,4 +1,4 @@
-import { fold, last, take, length, concat as listConcat } from "../types/list/module.f.js";
+import { fold, last, take, length, concat as listConcat, toArray } from "../types/list/module.f.js";
 import { join } from "../types/string/module.f.js";
 import { concat as stringConcat } from "../types/string/module.f.js";
 const foldNormalizeOp = input => state => {
@@ -21,9 +21,12 @@ const foldNormalizeOp = input => state => {
         }
     }
 };
-export const normalize = path => {
+export const parse = (path) => {
     const split = path.replaceAll('\\', '/').split('/');
-    const foldResult = fold(foldNormalizeOp)([])(split);
+    return toArray(fold(foldNormalizeOp)([])(split));
+};
+export const normalize = path => {
+    const foldResult = parse(path);
     return join('/')(foldResult);
 };
 export const concat = a => b => {

package/text/utf16/module.f.js

@@ -332,7 +332,7 @@ export const stringToCodePointList = (input) => toCodePointList(stringToList(inp
  * ```
  */
 export const listToString = fn(map(String.fromCharCode))
-    .then(reduce(concat)(''))
+    .map(reduce(concat)(''))
     .result;
 /**
  * Converts a list of Unicode code points (CodePoint) to a string.

package/types/bit_vec/module.f.d.ts

@@ -185,3 +185,4 @@ export declare const listToVec: ({ concat }: BitOrder) => (list: List<Vec>) => V
  * Repeats a vector to create a padded block of the desired length.
  */
 export declare const repeat: Fold<bigint, Vec>;
+export declare const isVec: <T>(v: Vec | T) => v is Vec;

package/types/bit_vec/module.f.js

@@ -202,3 +202,4 @@ export const listToVec = ({ concat }) => fold(flip(concat))(empty);
  * Repeats a vector to create a padded block of the desired length.
  */
 export const repeat = mRepeat({ identity: empty, operation: lsb.concat });
+export const isVec = (v) => typeof v === 'bigint';

package/types/effect/mock/module.f.d.ts

@@ -0,0 +1,5 @@
+import type { Effect, Operations } from "../module.f.ts";
+export type MemOperationMap<O extends Operations, S> = {
+    readonly [K in keyof O]: (state: S, payload: O[K][0]) => readonly [S, O[K][1]];
+};
+export declare const run: <O extends Operations, S>(o: MemOperationMap<O, S>) => (state: S) => <O1 extends O, T>(effect: Effect<O1, T>) => readonly [S, T];

package/types/effect/mock/module.f.js

@@ -0,0 +1,14 @@
+export const run = (o) => (state) => (effect) => {
+    let s = state;
+    let e = effect;
+    while (true) {
+        if ('pure' in e) {
+            return [s, e.pure];
+        }
+        const [cmd, payload, cont] = e.do;
+        const operation = o[cmd];
+        const [ns, m] = operation(s, payload);
+        s = ns;
+        e = cont(m);
+    }
+};

package/types/effect/module.d.ts

@@ -0,0 +1,2 @@
+import type { Effect, Operations, ToAsyncOperationMap } from "./module.f.ts";
+export declare const asyncRun: <O extends Operations>(map: ToAsyncOperationMap<O>) => <T, E extends Effect<O, T>>(effect: Effect<O, T>) => Promise<T>;

package/types/effect/module.f.d.ts

@@ -0,0 +1,23 @@
+export type Operations = {
+    readonly [command in string]: readonly [input: unknown, output: unknown];
+};
+export type Effect<O extends Operations, T> = Pure<O, T> | Do<O, T>;
+export type Map<O extends Operations, T> = {
+    readonly pipe: <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Effect<O | O1, R>;
+    readonly map: <O1 extends Operations, R>(f: (_: T) => R) => Effect<O | O1, R>;
+};
+export type Pure<O extends Operations, T> = {
+    readonly pure: T;
+} & Map<O, T>;
+export declare const pure: <O extends Operations, T>(value: T) => Pure<O, T>;
+export type One<O extends Operations, T, K extends keyof O & string> = readonly [K, O[K][0], (input: O[K][1]) => Effect<O, T>];
+export type Do<O extends Operations, T> = {
+    readonly do: {
+        readonly [K in keyof O & string]: One<O, T, K>;
+    }[keyof O & string];
+} & Map<O, T>;
+export declare const do_: <O extends Operations, K extends keyof O & string>(cmd: K, payload: O[K][0]) => Do<O, O[K][1]>;
+export type ToAsyncOperationMap<O extends Operations> = {
+    readonly [K in keyof O]: (payload: O[K][0]) => Promise<O[K][1]>;
+};
+export declare const all: <O extends Operations, T>(set: readonly Effect<O, T>[]) => Effect<O, readonly T[]>;

package/types/effect/module.f.js

@@ -0,0 +1,14 @@
+export const pure = (value) => ({
+    pure: value,
+    pipe: e => e(value),
+    map: f => pure(f(value))
+});
+const doFull = (cmd, payload, cont) => ({
+    do: [cmd, payload, cont],
+    pipe: e => doFull(cmd, payload, x => cont(x).pipe(e)),
+    map: f => doFull(cmd, payload, x => cont(x).map(f))
+});
+export const do_ = (cmd, payload) => doFull(cmd, payload, pure);
+const empty = pure([]);
+// TODO: replace with either a `Do` operation or as an addition to `Pure` and `Do`.
+export const all = (set) => set.reduce((previous, current) => previous.pipe(previousResult => current.map(currentResult => [...previousResult, currentResult])), empty);

package/types/effect/module.js

@@ -0,0 +1,11 @@
+export const asyncRun = (map) => async (effect) => {
+    while (true) {
+        if ('pure' in effect) {
+            return effect.pure;
+        }
+        const [command, payload, continuation] = effect.do;
+        const operation = map[command];
+        const result = await operation(payload);
+        effect = continuation(result);
+    }
+};

package/types/effect/node/module.f.d.ts

@@ -0,0 +1,52 @@
+import type { Vec } from '../../bit_vec/module.f.ts';
+import type { Result } from '../../result/module.f.ts';
+import { type Do, type Effect, type ToAsyncOperationMap } from '../module.f.ts';
+export type IoResult<T> = Result<T, unknown>;
+export type MakeDirectoryOptions = {
+    readonly recursive: true;
+};
+export type MkdirParam = readonly [string, MakeDirectoryOptions?];
+export type Mkdir = {
+    readonly mkdir: readonly [MkdirParam, IoResult<void>];
+};
+export declare const mkdir: (...p: MkdirParam) => Do<Mkdir, IoResult<void>>;
+export type ReadFile = {
+    readonly readFile: readonly [string, IoResult<Vec>];
+};
+export declare const readFile: (path: string) => Do<ReadFile, IoResult<Vec>>;
+/**
+ * Represents a directory entry (file or directory) in the filesystem
+ * @see https://nodejs.org/api/fs.html#class-fsdirent
+ */
+export type Dirent = {
+    readonly name: string;
+    readonly parentPath: string;
+    readonly isFile: boolean;
+};
+export type ReaddirOptions = {
+    readonly recursive?: true;
+};
+export type ReaddirParam = readonly [string, ReaddirOptions];
+export type Readdir = {
+    readonly readdir: readonly [ReaddirParam, IoResult<readonly Dirent[]>];
+};
+export declare const readdir: (...p: ReaddirParam) => Do<Readdir, IoResult<readonly Dirent[]>>;
+export type WriteFileParam = readonly [string, Vec];
+export type WriteFile = {
+    readonly writeFile: readonly [WriteFileParam, IoResult<void>];
+};
+export declare const writeFile: (...p: WriteFileParam) => Do<WriteFile, IoResult<void>>;
+export type Fs = Mkdir & ReadFile & Readdir & WriteFile;
+export type Error = {
+    readonly error: readonly [string, void];
+};
+export declare const error: (msg: string) => Do<Error, void>;
+export type Log = {
+    readonly log: readonly [string, void];
+};
+export declare const log: (msg: string) => Do<Log, void>;
+export type Console = Log & Error;
+export type NodeOperations = Console & Fs;
+export type NodeEffect<T> = Effect<NodeOperations, T>;
+export type NodeOperationMap = ToAsyncOperationMap<NodeOperations>;
+export type NodeProgram = (argv: readonly string[]) => NodeEffect<number>;

package/types/effect/node/module.f.js

@@ -0,0 +1,7 @@
+import { do_ } from "../module.f.js";
+export const mkdir = (...p) => do_('mkdir', p);
+export const readFile = (path) => do_('readFile', path);
+export const readdir = (...p) => do_('readdir', p);
+export const writeFile = (...p) => do_('writeFile', p);
+export const error = (msg) => do_('error', msg);
+export const log = (msg) => do_('log', msg);

package/types/effect/node/test.f.d.ts

@@ -0,0 +1,27 @@
+declare const _default: {
+    map: () => void;
+    mkdir: {
+        one: () => void;
+        rec: () => void;
+        nonRec: () => void;
+    };
+    readFile: {
+        one: () => void;
+        nested: () => void;
+        noSuchFile: () => void;
+        nestedPath: () => void;
+    };
+    readdir: {
+        one: () => void;
+        nonRecursive: () => void;
+        nested: () => void;
+        noSuchDir: () => void;
+    };
+    writeFile: {
+        one: () => void;
+        overwrite: () => void;
+        nestedPath: () => void;
+        directory: () => void;
+    };
+};
+export default _default;