@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Node.FS.Constants/index.js

@@ -0,0 +1,103 @@
+import * as $runtime from "../runtime.js";
+import {appendCopyMode, copyFile_EXCL, copyFile_FICLONE, copyFile_FICLONE_FORCE, f_OK, r_OK, w_OK, x_OK} from "./foreign.js";
+const $FileFlags = tag => tag;
+const R = /* #__PURE__ */ $FileFlags("R");
+const R_PLUS = /* #__PURE__ */ $FileFlags("R_PLUS");
+const RS = /* #__PURE__ */ $FileFlags("RS");
+const RS_PLUS = /* #__PURE__ */ $FileFlags("RS_PLUS");
+const W = /* #__PURE__ */ $FileFlags("W");
+const WX = /* #__PURE__ */ $FileFlags("WX");
+const W_PLUS = /* #__PURE__ */ $FileFlags("W_PLUS");
+const WX_PLUS = /* #__PURE__ */ $FileFlags("WX_PLUS");
+const A = /* #__PURE__ */ $FileFlags("A");
+const AX = /* #__PURE__ */ $FileFlags("AX");
+const A_PLUS = /* #__PURE__ */ $FileFlags("A_PLUS");
+const AX_PLUS = /* #__PURE__ */ $FileFlags("AX_PLUS");
+const semigroupCopyMode = {append: l => r => appendCopyMode(l, r)};
+const showFileFlags = {
+  show: v => {
+    if (v === "R") { return "R"; }
+    if (v === "R_PLUS") { return "R_PLUS"; }
+    if (v === "RS") { return "RS"; }
+    if (v === "RS_PLUS") { return "RS_PLUS"; }
+    if (v === "W") { return "W"; }
+    if (v === "WX") { return "WX"; }
+    if (v === "W_PLUS") { return "W_PLUS"; }
+    if (v === "WX_PLUS") { return "WX_PLUS"; }
+    if (v === "A") { return "A"; }
+    if (v === "AX") { return "AX"; }
+    if (v === "A_PLUS") { return "A_PLUS"; }
+    if (v === "AX_PLUS") { return "AX_PLUS"; }
+    $runtime.fail();
+  }
+};
+const fileFlagsToNode = ff => {
+  if (ff === "R") { return "r"; }
+  if (ff === "R_PLUS") { return "r+"; }
+  if (ff === "RS") { return "rs"; }
+  if (ff === "RS_PLUS") { return "rs+"; }
+  if (ff === "W") { return "w"; }
+  if (ff === "WX") { return "wx"; }
+  if (ff === "W_PLUS") { return "w+"; }
+  if (ff === "WX_PLUS") { return "wx+"; }
+  if (ff === "A") { return "a"; }
+  if (ff === "AX") { return "ax"; }
+  if (ff === "A_PLUS") { return "a+"; }
+  if (ff === "AX_PLUS") { return "ax+"; }
+  $runtime.fail();
+};
+const eqFileFlags = {
+  eq: x => y => (() => {
+    if (x === "R") { return "R"; }
+    if (x === "R_PLUS") { return "R_PLUS"; }
+    if (x === "RS") { return "RS"; }
+    if (x === "RS_PLUS") { return "RS_PLUS"; }
+    if (x === "W") { return "W"; }
+    if (x === "WX") { return "WX"; }
+    if (x === "W_PLUS") { return "W_PLUS"; }
+    if (x === "WX_PLUS") { return "WX_PLUS"; }
+    if (x === "A") { return "A"; }
+    if (x === "AX") { return "AX"; }
+    if (x === "A_PLUS") { return "A_PLUS"; }
+    if (x === "AX_PLUS") { return "AX_PLUS"; }
+    $runtime.fail();
+  })() === (() => {
+    if (y === "R") { return "R"; }
+    if (y === "R_PLUS") { return "R_PLUS"; }
+    if (y === "RS") { return "RS"; }
+    if (y === "RS_PLUS") { return "RS_PLUS"; }
+    if (y === "W") { return "W"; }
+    if (y === "WX") { return "WX"; }
+    if (y === "W_PLUS") { return "W_PLUS"; }
+    if (y === "WX_PLUS") { return "WX_PLUS"; }
+    if (y === "A") { return "A"; }
+    if (y === "AX") { return "AX"; }
+    if (y === "A_PLUS") { return "A_PLUS"; }
+    if (y === "AX_PLUS") { return "AX_PLUS"; }
+    $runtime.fail();
+  })()
+};
+const defaultCopyMode = copyFile_EXCL;
+const defaultAccessMode = f_OK;
+export {
+  $FileFlags,
+  A,
+  AX,
+  AX_PLUS,
+  A_PLUS,
+  R,
+  RS,
+  RS_PLUS,
+  R_PLUS,
+  W,
+  WX,
+  WX_PLUS,
+  W_PLUS,
+  defaultAccessMode,
+  defaultCopyMode,
+  eqFileFlags,
+  fileFlagsToNode,
+  semigroupCopyMode,
+  showFileFlags
+};
+export * from "./foreign.js";

package/output-es/Node.FS.Perms/index.js

@@ -0,0 +1,125 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEnum from "../Data.Enum/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dInt from "../Data.Int/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCodePoints from "../Data.String.CodePoints/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Data$dString$dCommon from "../Data.String.Common/index.js";
+const compare = /* #__PURE__ */ (() => Data$dOrd.ordArray(Data$dOrd.ordBoolean).compare)();
+const write = {r: false, w: true, x: false};
+const semiringPerm = {
+  add: v => v1 => ({r: v.r || v1.r, w: v.w || v1.w, x: v.x || v1.x}),
+  zero: {r: false, w: false, x: false},
+  mul: v => v1 => ({r: v.r && v1.r, w: v.w && v1.w, x: v.x && v1.x}),
+  one: {r: true, w: true, x: true}
+};
+const read = {r: true, w: false, x: false};
+const permToString = x => Data$dShow.showIntImpl(((x.r ? 4 : 0) + (x.w ? 2 : 0) | 0) + (x.x ? 1 : 0) | 0);
+const permsToString = v => "0" + permToString(v.u) + permToString(v.g) + permToString(v.o);
+const permsToInt = /* #__PURE__ */ (() => {
+  const $0 = Data$dInt.fromStringAs(8);
+  return x => {
+    const $1 = $0(permsToString(x));
+    if ($1.tag === "Just") { return $1._1; }
+    $runtime.fail();
+  };
+})();
+const none = /* #__PURE__ */ (() => semiringPerm.zero)();
+const mkPerms = u => g => o => ({u, g, o});
+const mkPerm = r => w => x => ({r, w, x});
+const execute = {r: false, w: false, x: true};
+const permFromChar = c => {
+  if (c === "0") { return Data$dMaybe.$Maybe("Just", semiringPerm.zero); }
+  if (c === "1") { return Data$dMaybe.$Maybe("Just", execute); }
+  if (c === "2") { return Data$dMaybe.$Maybe("Just", write); }
+  if (c === "3") { return Data$dMaybe.$Maybe("Just", {r: false, w: true, x: true}); }
+  if (c === "4") { return Data$dMaybe.$Maybe("Just", read); }
+  if (c === "5") { return Data$dMaybe.$Maybe("Just", {r: true, w: false, x: true}); }
+  if (c === "6") { return Data$dMaybe.$Maybe("Just", {r: true, w: true, x: false}); }
+  if (c === "7") { return Data$dMaybe.$Maybe("Just", {r: true, w: true, x: true}); }
+  return Data$dMaybe.Nothing;
+};
+const permsFromString = /* #__PURE__ */ (() => {
+  const $0 = Data$dEnum.fromCharCode(48);
+  return x => {
+    const $1 = Data$dString$dCodeUnits.toCharArray((() => {
+      const $1 = Data$dString$dCodeUnits.charAt(0)(x);
+      if ($1.tag === "Nothing") { return false; }
+      return $1.tag === "Just" && $1._1 === $0;
+    })()
+      ? Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.length(Data$dString$dCodePoints.take(1)(x)))(x)
+      : x);
+    if ($1.length === 3) {
+      const $2 = permFromChar($1[0]);
+      if ($2.tag === "Just") {
+        const $3 = permFromChar($1[1]);
+        if ($3.tag === "Just") {
+          const $4 = permFromChar($1[2]);
+          if ($4.tag === "Just") { return Data$dMaybe.$Maybe("Just", {u: $2._1, g: $3._1, o: $4._1}); }
+        }
+      }
+    }
+    return Data$dMaybe.Nothing;
+  };
+})();
+const eqPerm = {eq: ra => rb => ra.r === rb.r && ra.w === rb.w && ra.x === rb.x};
+const eqPerms = {
+  eq: ra => rb => ra.g.r === rb.g.r && ra.g.w === rb.g.w && ra.g.x === rb.g.x && ra.o.r === rb.o.r && ra.o.w === rb.o.w && ra.o.x === rb.o.x && ra.u.r === rb.u.r && ra.u.w === rb.u.w && ra.u.x === rb.u.x
+};
+const ordPerm = {compare: v => v1 => compare([v.r, v.w, v.x])([v1.r, v1.w, v1.x]), Eq0: () => eqPerm};
+const compare1 = /* #__PURE__ */ (() => Data$dOrd.ordArray(ordPerm).compare)();
+const ordPerms = {compare: v => v1 => compare1([v.u, v.g, v.o])([v1.u, v1.g, v1.o]), Eq0: () => eqPerms};
+const all = /* #__PURE__ */ (() => semiringPerm.one)();
+const permsAll = /* #__PURE__ */ (() => ({u: semiringPerm.one, g: semiringPerm.one, o: semiringPerm.one}))();
+const permsReadWrite = /* #__PURE__ */ (() => ({u: semiringPerm.one, g: semiringPerm.one, o: semiringPerm.zero}))();
+const showPerm = {
+  show: v => {
+    if (!v.r && !v.w && !v.x) { return "none"; }
+    if (v.r && v.w && v.x) { return "all"; }
+    return Data$dString$dCommon.joinWith(" + ")([...v.r ? ["read"] : [], ...v.w ? ["write"] : [], ...v.x ? ["execute"] : []]);
+  }
+};
+const showPerms = {
+  show: v => "mkPerms " + Data$dString$dCommon.joinWith(" ")(Data$dFunctor.arrayMap(perm => {
+    const str = showPerm.show(perm);
+    if (
+      (() => {
+        const $0 = Data$dString$dCodePoints.indexOf(" ")(str);
+        if ($0.tag === "Nothing") { return true; }
+        if ($0.tag === "Just") { return false; }
+        $runtime.fail();
+      })()
+    ) {
+      return str;
+    }
+    return "(" + str + ")";
+  })([v.u, v.g, v.o]))
+};
+export {
+  all,
+  compare,
+  compare1,
+  eqPerm,
+  eqPerms,
+  execute,
+  mkPerm,
+  mkPerms,
+  none,
+  ordPerm,
+  ordPerms,
+  permFromChar,
+  permToString,
+  permsAll,
+  permsFromString,
+  permsReadWrite,
+  permsToInt,
+  permsToString,
+  read,
+  semiringPerm,
+  showPerm,
+  showPerms,
+  write
+};

package/output-es/Node.FS.Stats/foreign.js

@@ -0,0 +1,27 @@
+export { inspect as showStatsObj } from "util";
+
+export const isBlockDeviceImpl = (s) => s.isBlockDevice();
+export const isCharacterDeviceImpl = (s) => s.isCharacterDevice();
+export const isDirectoryImpl = (s) => s.isDirectory();
+export const isFIFOImpl = (s) => s.isFIFO();
+export const isFileImpl = (s) => s.isFile();
+export const isSocketImpl = (s) => s.isSocket();
+export const isSymbolicLinkImpl = (s) => s.isSymbolicLink();
+export const devImpl = (s) => s.dev;
+export const inodeImpl = (s) => s.ino;
+export const modeImpl = (s) => s.mode;
+export const nlinkImpl = (s) => s.nlink;
+export const uidImpl = (s) => s.uid;
+export const gidImpl = (s) => s.gid;
+export const rdevImpl = (s) => s.rdev;
+export const sizeImpl = (s) => s.size;
+export const blkSizeImpl = (s) => s.blkSize;
+export const blocksImpl = (s) => s.blocks;
+export const accessedTimeMsImpl = (s) => s.atimeMs;
+export const modifiedTimeMsImpl = (s) => s.mtimeMs;
+export const statusChangedTimeMsImpl = (s) => s.ctimeMs;
+export const birthtimeMsImpl = (s) => s.birthtimeMs;
+export const accessedTimeImpl = (s) => s.atime;
+export const modifiedTimeImpl = (s) => s.mtime;
+export const statusChangedTimeImpl = (s) => s.ctime;
+export const birthTimeImpl = (s) => s.birthtime;

package/output-es/Node.FS.Stats/index.js

@@ -0,0 +1,102 @@
+import * as Data$dDateTime$dInstant from "../Data.DateTime.Instant/index.js";
+import * as Data$dJSDate from "../Data.JSDate/index.js";
+import * as Partial from "../Partial/index.js";
+import {
+  accessedTimeImpl,
+  accessedTimeMsImpl,
+  birthTimeImpl,
+  birthtimeMsImpl,
+  blkSizeImpl,
+  blocksImpl,
+  devImpl,
+  gidImpl,
+  inodeImpl,
+  isBlockDeviceImpl,
+  isCharacterDeviceImpl,
+  isDirectoryImpl,
+  isFIFOImpl,
+  isFileImpl,
+  isSocketImpl,
+  isSymbolicLinkImpl,
+  modeImpl,
+  modifiedTimeImpl,
+  modifiedTimeMsImpl,
+  nlinkImpl,
+  rdevImpl,
+  showStatsObj,
+  sizeImpl,
+  statusChangedTimeImpl,
+  statusChangedTimeMsImpl,
+  uidImpl
+} from "./foreign.js";
+const uid = s => uidImpl(s);
+const statusChangedTimeMs = s => statusChangedTimeMsImpl(s);
+const statusChangedTime = s => {
+  const $0 = Data$dJSDate.toInstant(statusChangedTimeImpl(s));
+  if ($0.tag === "Just") { return Data$dDateTime$dInstant.toDateTime($0._1); }
+  return Partial._crashWith("Impossible: `statusChangedTime` returned invalid DateTime value.");
+};
+const size = s => sizeImpl(s);
+const showStats = {show: s => "Stats " + showStatsObj(s)};
+const rdev = s => rdevImpl(s);
+const nlink = s => nlinkImpl(s);
+const modifiedTimeMs = s => modifiedTimeMsImpl(s);
+const modifiedTime = s => {
+  const $0 = Data$dJSDate.toInstant(modifiedTimeImpl(s));
+  if ($0.tag === "Just") { return Data$dDateTime$dInstant.toDateTime($0._1); }
+  return Partial._crashWith("Impossible: `modifiedTime` returned invalid DateTime value.");
+};
+const mode = s => modeImpl(s);
+const isSymbolicLink = s => isSymbolicLinkImpl(s);
+const isSocket = s => isSocketImpl(s);
+const isFile = s => isFileImpl(s);
+const isFIFO = s => isFIFOImpl(s);
+const isDirectory = s => isDirectoryImpl(s);
+const isCharacterDevice = s => isCharacterDeviceImpl(s);
+const isBlockDevice = s => isBlockDeviceImpl(s);
+const inode = s => inodeImpl(s);
+const gid = s => gidImpl(s);
+const dev = s => devImpl(s);
+const blocks = s => blocksImpl(s);
+const blkSize = s => blkSizeImpl(s);
+const birthtimeMs = s => birthtimeMsImpl(s);
+const birthTime = s => {
+  const $0 = Data$dJSDate.toInstant(birthTimeImpl(s));
+  if ($0.tag === "Just") { return Data$dDateTime$dInstant.toDateTime($0._1); }
+  return Partial._crashWith("Impossible: `birthTime` returned invalid DateTime value.");
+};
+const accessedTimeMs = s => accessedTimeMsImpl(s);
+const accessedTime = s => {
+  const $0 = Data$dJSDate.toInstant(accessedTimeImpl(s));
+  if ($0.tag === "Just") { return Data$dDateTime$dInstant.toDateTime($0._1); }
+  return Partial._crashWith("Impossible: `accessedTime` returned invalid DateTime value.");
+};
+export {
+  accessedTime,
+  accessedTimeMs,
+  birthTime,
+  birthtimeMs,
+  blkSize,
+  blocks,
+  dev,
+  gid,
+  inode,
+  isBlockDevice,
+  isCharacterDevice,
+  isDirectory,
+  isFIFO,
+  isFile,
+  isSocket,
+  isSymbolicLink,
+  mode,
+  modifiedTime,
+  modifiedTimeMs,
+  nlink,
+  rdev,
+  showStats,
+  size,
+  statusChangedTime,
+  statusChangedTimeMs,
+  uid
+};
+export * from "./foreign.js";

package/output-es/Node.FS.Stream/foreign.js

@@ -0,0 +1,11 @@
+import fs from "node:fs";
+
+export const createReadStreamImpl = (path) => fs.createReadStream(path);
+export const createReadStreamOptsImpl = (path, opts) => fs.createReadStream(path, opts);
+export const fdCreateReadStreamImpl = (fd) => fs.createReadStream(null, { fd });
+export const fdCreateReadStreamOptsImpl = (fd, opts) => fs.createReadStream(null, { ...opts, fd});
+
+export const createWriteStreamImpl = (path) => fs.createWriteStream(path);
+export const createWriteStreamOptsImpl = (path, opts) => fs.createWriteStream(path, opts);
+export const fdCreateWriteStreamImpl = (fd) => fs.createWriteStream(null, { fd });
+export const fdCreateWriteStreamOptsImpl = (fd, opts) => fs.createWriteStream(null, { ...opts, fd});

package/output-es/Node.FS.Stream/index.js

@@ -0,0 +1,20 @@
+import {
+  createReadStreamImpl,
+  createReadStreamOptsImpl,
+  createWriteStreamImpl,
+  createWriteStreamOptsImpl,
+  fdCreateReadStreamImpl,
+  fdCreateReadStreamOptsImpl,
+  fdCreateWriteStreamImpl,
+  fdCreateWriteStreamOptsImpl
+} from "./foreign.js";
+const fdCreateWriteStream$p = () => f => opts => () => fdCreateWriteStreamOptsImpl(f, opts);
+const fdCreateWriteStream = f => () => fdCreateWriteStreamImpl(f);
+const fdCreateReadStream$p = () => f => opts => () => fdCreateReadStreamOptsImpl(f, opts);
+const fdCreateReadStream = f => () => fdCreateReadStreamImpl(f);
+const createWriteStream$p = () => f => opts => () => createWriteStreamOptsImpl(f, opts);
+const createWriteStream = f => () => createWriteStreamImpl(f);
+const createReadStream$p = () => path => opts => () => createReadStreamOptsImpl(path, opts);
+const createReadStream = p => () => createReadStreamImpl(p);
+export {createReadStream, createReadStream$p, createWriteStream, createWriteStream$p, fdCreateReadStream, fdCreateReadStream$p, fdCreateWriteStream, fdCreateWriteStream$p};
+export * from "./foreign.js";

package/output-es/Node.FS.Sync/foreign.js

@@ -0,0 +1,30 @@
+export { 
+  accessSync as accessImpl,
+  copyFileSync as copyFileImpl,
+  mkdtempSync as mkdtempImpl,
+  renameSync as renameSyncImpl,
+  truncateSync as truncateSyncImpl,
+  chownSync as chownSyncImpl,
+  chmodSync as chmodSyncImpl,
+  statSync as statSyncImpl,
+  lstatSync as lstatSyncImpl,
+  linkSync as linkSyncImpl,
+  symlinkSync as symlinkSyncImpl,
+  readlinkSync as readlinkSyncImpl,
+  realpathSync as realpathSyncImpl,
+  unlinkSync as unlinkSyncImpl,
+  rmdirSync as rmdirSyncImpl,
+  rmSync as rmSyncImpl,
+  mkdirSync as mkdirSyncImpl,
+  readdirSync as readdirSyncImpl,
+  utimesSync as utimesSyncImpl,
+  readFileSync as readFileSyncImpl,
+  writeFileSync as writeFileSyncImpl,
+  appendFileSync as appendFileSyncImpl,
+  existsSync as existsSyncImpl,
+  openSync as openSyncImpl,
+  readSync as readSyncImpl,
+  writeSync as writeSyncImpl,
+  fsyncSync as fsyncSyncImpl,
+  closeSync as closeSyncImpl
+} from "node:fs";

package/output-es/Node.FS.Sync/index.js

@@ -0,0 +1,258 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dDateTime$dInstant from "../Data.DateTime.Instant/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dInt from "../Data.Int/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Data$dNumber from "../Data.Number/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Node$dBuffer$dImmutable from "../Node.Buffer.Immutable/index.js";
+import * as Node$dEncoding from "../Node.Encoding/index.js";
+import * as Node$dFS$dConstants from "../Node.FS.Constants/index.js";
+import * as Node$dFS$dPerms from "../Node.FS.Perms/index.js";
+import {
+  accessImpl,
+  appendFileSyncImpl,
+  chmodSyncImpl,
+  chownSyncImpl,
+  closeSyncImpl,
+  copyFileImpl,
+  existsSyncImpl,
+  fsyncSyncImpl,
+  linkSyncImpl,
+  lstatSyncImpl,
+  mkdirSyncImpl,
+  mkdtempImpl,
+  openSyncImpl,
+  readFileSyncImpl,
+  readSyncImpl,
+  readdirSyncImpl,
+  readlinkSyncImpl,
+  realpathSyncImpl,
+  renameSyncImpl,
+  rmSyncImpl,
+  rmdirSyncImpl,
+  statSyncImpl,
+  symlinkSyncImpl,
+  truncateSyncImpl,
+  unlinkSyncImpl,
+  utimesSyncImpl,
+  writeFileSyncImpl,
+  writeSyncImpl
+} from "./foreign.js";
+const writeTextFile = encoding => file => text => {
+  const $0 = {
+    encoding: (() => {
+      if (encoding === "ASCII") { return "ASCII"; }
+      if (encoding === "UTF8") { return "UTF8"; }
+      if (encoding === "UTF16LE") { return "UTF16LE"; }
+      if (encoding === "UCS2") { return "UCS2"; }
+      if (encoding === "Base64") { return "Base64"; }
+      if (encoding === "Base64Url") { return "Base64Url"; }
+      if (encoding === "Latin1") { return "Latin1"; }
+      if (encoding === "Binary") { return "Binary"; }
+      if (encoding === "Hex") { return "Hex"; }
+      $runtime.fail();
+    })()
+  };
+  return () => writeFileSyncImpl(file, text, $0);
+};
+const writeFile = file => buff => () => writeFileSyncImpl(file, buff, {});
+const utimes = file => atime => mtime => {
+  const $0 = $runtime.intDiv(Data$dInt.unsafeClamp(Data$dNumber.round(Data$dDateTime$dInstant.fromDateTime(atime))), 1000);
+  const $1 = $runtime.intDiv(Data$dInt.unsafeClamp(Data$dNumber.round(Data$dDateTime$dInstant.fromDateTime(mtime))), 1000);
+  return () => utimesSyncImpl(file, $0, $1);
+};
+const unlink = file => () => unlinkSyncImpl(file);
+const truncate = file => len => () => truncateSyncImpl(file, len);
+const symlink = src => dst => ty => {
+  const $0 = (() => {
+    if (ty === "FileLink") { return "file"; }
+    if (ty === "DirLink") { return "dir"; }
+    if (ty === "JunctionLink") { return "junction"; }
+    $runtime.fail();
+  })();
+  return () => symlinkSyncImpl(src, dst, $0);
+};
+const stat = file => () => statSyncImpl(file);
+const rmdir$p = path => opts => () => rmdirSyncImpl(path, opts);
+const rmdir = path => () => rmdirSyncImpl(path, {maxRetries: 0, retryDelay: 100});
+const rm$p = path => opts => () => rmSyncImpl(path, opts);
+const rm = path => () => rmSyncImpl(path, {force: false, maxRetries: 100, recursive: false, retryDelay: 1000});
+const rename = oldFile => newFile => () => renameSyncImpl(oldFile, newFile);
+const realpath$p = path => cache => () => realpathSyncImpl(path, cache);
+const realpath = path => () => realpathSyncImpl(path, {});
+const readlink = path => () => readlinkSyncImpl(path);
+const readdir = file => () => readdirSyncImpl(file);
+const readTextFile = encoding => file => {
+  const $0 = {
+    encoding: (() => {
+      if (encoding === "ASCII") { return "ASCII"; }
+      if (encoding === "UTF8") { return "UTF8"; }
+      if (encoding === "UTF16LE") { return "UTF16LE"; }
+      if (encoding === "UCS2") { return "UCS2"; }
+      if (encoding === "Base64") { return "Base64"; }
+      if (encoding === "Base64Url") { return "Base64Url"; }
+      if (encoding === "Latin1") { return "Latin1"; }
+      if (encoding === "Binary") { return "Binary"; }
+      if (encoding === "Hex") { return "Hex"; }
+      $runtime.fail();
+    })()
+  };
+  return () => readFileSyncImpl(file, $0);
+};
+const readFile = file => () => readFileSyncImpl(file, {});
+const mkdtemp$p = prefix => encoding => {
+  const $0 = (() => {
+    if (encoding === "ASCII") { return "ascii"; }
+    if (encoding === "UTF8") { return "utf8"; }
+    if (encoding === "UTF16LE") { return "utf16le"; }
+    if (encoding === "UCS2") { return "ucs2"; }
+    if (encoding === "Base64") { return "base64"; }
+    if (encoding === "Base64Url") { return "base64url"; }
+    if (encoding === "Latin1") { return "latin1"; }
+    if (encoding === "Binary") { return "binary"; }
+    if (encoding === "Hex") { return "hex"; }
+    $runtime.fail();
+  })();
+  return () => mkdtempImpl(prefix, $0);
+};
+const mkdtemp = prefix => mkdtemp$p(prefix)(Node$dEncoding.UTF8);
+const mkdir$p = file => v => {
+  const $0 = {recursive: v.recursive, mode: Node$dFS$dPerms.permsToString(v.mode)};
+  return () => mkdirSyncImpl(file, $0);
+};
+const mkdir = path => {
+  const $0 = {
+    recursive: false,
+    mode: Node$dFS$dPerms.permsToString({u: Node$dFS$dPerms.semiringPerm.one, g: Node$dFS$dPerms.semiringPerm.one, o: Node$dFS$dPerms.semiringPerm.one})
+  };
+  return () => mkdirSyncImpl(path, $0);
+};
+const lstat = file => () => lstatSyncImpl(file);
+const link = src => dst => () => linkSyncImpl(src, dst);
+const fdWrite = fd => buff => off => len => pos => {
+  const $0 = (() => {
+    if (pos.tag === "Nothing") { return Data$dNullable.null; }
+    if (pos.tag === "Just") { return Data$dNullable.notNull(pos._1); }
+    $runtime.fail();
+  })();
+  return () => writeSyncImpl(fd, buff, off, len, $0);
+};
+const fdRead = fd => buff => off => len => pos => {
+  const $0 = (() => {
+    if (pos.tag === "Nothing") { return Data$dNullable.null; }
+    if (pos.tag === "Just") { return Data$dNullable.notNull(pos._1); }
+    $runtime.fail();
+  })();
+  return () => readSyncImpl(fd, buff, off, len, $0);
+};
+const fdOpen = file => flags => mode => {
+  const $0 = (() => {
+    if (flags === "R") { return "r"; }
+    if (flags === "R_PLUS") { return "r+"; }
+    if (flags === "RS") { return "rs"; }
+    if (flags === "RS_PLUS") { return "rs+"; }
+    if (flags === "W") { return "w"; }
+    if (flags === "WX") { return "wx"; }
+    if (flags === "W_PLUS") { return "w+"; }
+    if (flags === "WX_PLUS") { return "wx+"; }
+    if (flags === "A") { return "a"; }
+    if (flags === "AX") { return "ax"; }
+    if (flags === "A_PLUS") { return "a+"; }
+    if (flags === "AX_PLUS") { return "ax+"; }
+    $runtime.fail();
+  })();
+  const $1 = (() => {
+    if (mode.tag === "Nothing") { return Data$dNullable.null; }
+    if (mode.tag === "Just") { return Data$dNullable.notNull(mode._1); }
+    $runtime.fail();
+  })();
+  return () => openSyncImpl(file, $0, $1);
+};
+const fdNext = fd => buff => () => fdRead(fd)(buff)(0)(Node$dBuffer$dImmutable.size(buff))(Data$dMaybe.Nothing)();
+const fdFlush = fd => () => fsyncSyncImpl(fd);
+const fdClose = fd => () => closeSyncImpl(fd);
+const fdAppend = fd => buff => () => fdWrite(fd)(buff)(0)(Node$dBuffer$dImmutable.size(buff))(Data$dMaybe.Nothing)();
+const exists = file => () => existsSyncImpl(file);
+const copyFile$p = src => dest => mode => () => copyFileImpl(src, dest, mode);
+const copyFile = src => dest => () => copyFileImpl(src, dest, Node$dFS$dConstants.copyFile_EXCL);
+const chown = file => uid => gid => () => chownSyncImpl(file, uid, gid);
+const chmod = file => perms => {
+  const $0 = Node$dFS$dPerms.permsToString(perms);
+  return () => chmodSyncImpl(file, $0);
+};
+const appendTextFile = encoding => file => buff => {
+  const $0 = {
+    encoding: (() => {
+      if (encoding === "ASCII") { return "ASCII"; }
+      if (encoding === "UTF8") { return "UTF8"; }
+      if (encoding === "UTF16LE") { return "UTF16LE"; }
+      if (encoding === "UCS2") { return "UCS2"; }
+      if (encoding === "Base64") { return "Base64"; }
+      if (encoding === "Base64Url") { return "Base64Url"; }
+      if (encoding === "Latin1") { return "Latin1"; }
+      if (encoding === "Binary") { return "Binary"; }
+      if (encoding === "Hex") { return "Hex"; }
+      $runtime.fail();
+    })()
+  };
+  return () => appendFileSyncImpl(file, buff, $0);
+};
+const appendFile = file => buff => () => appendFileSyncImpl(file, buff, {});
+const access$p = path => mode => {
+  const $0 = Effect$dException.catchException(x => () => Data$dEither.$Either("Left", x))(() => {
+    const a$p = accessImpl(path, mode);
+    return Data$dEither.$Either("Right", a$p);
+  });
+  return () => {
+    const a$p = $0();
+    if (a$p.tag === "Left") { return Data$dMaybe.$Maybe("Just", a$p._1); }
+    if (a$p.tag === "Right") { return Data$dMaybe.Nothing; }
+    $runtime.fail();
+  };
+};
+const access = a => access$p(a)(Node$dFS$dConstants.f_OK);
+export {
+  access,
+  access$p,
+  appendFile,
+  appendTextFile,
+  chmod,
+  chown,
+  copyFile,
+  copyFile$p,
+  exists,
+  fdAppend,
+  fdClose,
+  fdFlush,
+  fdNext,
+  fdOpen,
+  fdRead,
+  fdWrite,
+  link,
+  lstat,
+  mkdir,
+  mkdir$p,
+  mkdtemp,
+  mkdtemp$p,
+  readFile,
+  readTextFile,
+  readdir,
+  readlink,
+  realpath,
+  realpath$p,
+  rename,
+  rm,
+  rm$p,
+  rmdir,
+  rmdir$p,
+  stat,
+  symlink,
+  truncate,
+  unlink,
+  utimes,
+  writeFile,
+  writeTextFile
+};
+export * from "./foreign.js";