@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Node.EventEmitter/index.js

@@ -0,0 +1,142 @@
+// | ## Handling events emitted by an `EventEmitter`
+// |
+// | One can add callbacks to an `EventEmitter` on two major axes:
+// | - whether listener is added to the **end** (i.e. `on`) or **start** (i.e. `prependListener`) of the array
+// | - whether a listener is automatically removed after the first event (i.e. `once` or `prependOnceListener`).
+// |
+// | This module provides functions for each of the above 4 callback-adding functions
+// | If `<fn>` is either `on`, `once`, `prependListener`, or `prependOnceListener`, then this module exposes
+// | 1. `<fn>` - returns a callback that removes the listener
+// | 2. `<fn>_` - does not return a callback that can remove the listener
+// |
+// | ## Defining events emitted by an `EventEmitter`
+// |
+// | Below, we'll provide an example for how to define an event handler for a type. Let's assume the following:
+// | - There is a type `Foo` that exends `EventEmitter`
+// | - `Foo` values can handle "bar" events
+// | - a "bar" event takes the following callback: `EffectFn2 (Nullable Error) String Unit`
+// | - the `String` value is always either "red", "green", or "blue"
+// |
+// | Then we would write
+// | ```
+// | data Color 
+// |   = Red 
+// |   | Green 
+// |   | Blue
+// |
+// | -- Note: see docs on `EventHandle` 
+// | -- for the below naming convention justification 
+// | -- of suffixing an event name with `H`.
+// | barH 
+// |   :: EventHandle 
+// |        Foo 
+// |        (Maybe Error -> Color -> Effect Unit) 
+// |        (EffectFn1 (Nullable Error) String Unit)
+// | barH = EventHandle "bar" $ \psCb -> 
+// |   mkEffectFn2 \nullableError str ->
+// |     psCb (toMaybe nullableError) case str of
+// |       "red" -> Red
+// |       "green" -> Green
+// |       "blue" -> Blue
+// |       _ -> 
+// |         unsafeCrashWith $ 
+// |           "Impossible String value for event 'bar': " <> show str
+// | ```
+// |
+// | ## Emitting events via an `EventEmitter`
+// |
+// | Unfortunately, there isn't a good way to emit events safely in PureScript. If one wants to emit an event
+// | in PureScript code that will be consumed by PureScript code, there are better abstractions to use than `EventEmitter`.
+// | If one wants to emit an event in PureScript code that will be consumed by JavaScript code, then
+// | the `unsafeEmitFn` function can be used to call n-ary functions. However, this is very unsafe. See its docs for more context.
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Effect$dUncurried from "../Effect.Uncurried/index.js";
+import {
+  new as $$new,
+  eventNamesImpl,
+  getMaxListenersImpl,
+  listenerCountImpl,
+  setMaxListenersImpl,
+  symbolOrStr,
+  unsafeEmitFn,
+  unsafeOff,
+  unsafeOn,
+  unsafeOnce,
+  unsafePrependListener,
+  unsafePrependOnceListener
+} from "./foreign.js";
+const $EventHandle = (_1, _2) => ({tag: "EventHandle", _1, _2});
+const EventHandle = value0 => value1 => $EventHandle(value0, value1);
+const subscribeSameFunction = (onXFn, eventEmitter, eventName, jsCb) => {
+  onXFn(eventEmitter, eventName, jsCb);
+  return () => unsafeOff(eventEmitter, eventName, jsCb);
+};
+const setMaxListeners = max => emitter => () => setMaxListenersImpl(emitter, max);
+const setUnlimitedListeners = /* #__PURE__ */ setMaxListeners(0);
+const removeListenerH = /* #__PURE__ */ $EventHandle("removeListener", cb => jsSymbol => cb(symbolOrStr(Data$dEither.Left, Data$dEither.Right, jsSymbol))());
+const prependOnceListener_ = v => psCb => eventEmitter => {
+  const $0 = v._1;
+  const $1 = v._2(psCb);
+  return () => unsafePrependOnceListener(eventEmitter, $0, $1);
+};
+const prependOnceListener = v => psCb => eventEmitter => {
+  const $0 = v._1;
+  const $1 = v._2(psCb);
+  return () => subscribeSameFunction(unsafePrependOnceListener, eventEmitter, $0, $1);
+};
+const prependListener_ = v => psCb => eventEmitter => {
+  const $0 = v._1;
+  const $1 = v._2(psCb);
+  return () => unsafePrependListener(eventEmitter, $0, $1);
+};
+const prependListener = v => psCb => eventEmitter => {
+  const $0 = v._1;
+  const $1 = v._2(psCb);
+  return () => subscribeSameFunction(unsafePrependListener, eventEmitter, $0, $1);
+};
+const once_ = v => psCb => eventEmitter => {
+  const $0 = v._1;
+  const $1 = v._2(psCb);
+  return () => unsafeOnce(eventEmitter, $0, $1);
+};
+const once = v => psCb => eventEmitter => {
+  const $0 = v._1;
+  const $1 = v._2(psCb);
+  return () => subscribeSameFunction(unsafeOnce, eventEmitter, $0, $1);
+};
+const on_ = v => psCb => eventEmitter => {
+  const $0 = v._1;
+  const $1 = v._2(psCb);
+  return () => unsafeOn(eventEmitter, $0, $1);
+};
+const on = v => psCb => eventEmitter => {
+  const $0 = v._1;
+  const $1 = v._2(psCb);
+  return () => subscribeSameFunction(unsafeOn, eventEmitter, $0, $1);
+};
+const newListenerH = /* #__PURE__ */ $EventHandle("newListener", cb => jsSymbol => cb(symbolOrStr(Data$dEither.Left, Data$dEither.Right, jsSymbol))());
+const listenerCount = emitter => eventName => () => listenerCountImpl(emitter, eventName);
+const getMaxListeners = /* #__PURE__ */ Effect$dUncurried.runEffectFn1(getMaxListenersImpl);
+const eventNames = ee => Data$dFunctor.arrayMap(x => symbolOrStr(Data$dEither.Left, Data$dEither.Right, x))(eventNamesImpl(ee));
+export {
+  $EventHandle,
+  EventHandle,
+  eventNames,
+  getMaxListeners,
+  listenerCount,
+  newListenerH,
+  on,
+  on_,
+  once,
+  once_,
+  prependListener,
+  prependListener_,
+  prependOnceListener,
+  prependOnceListener_,
+  removeListenerH,
+  setMaxListeners,
+  setUnlimitedListeners,
+  subscribeSameFunction
+};
+export * from "./foreign.js";

package/output-es/Node.EventEmitter.UtilTypes/index.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,27 @@
+import * as $runtime from "../runtime.js";
+const $SymlinkType = tag => tag;
+const FileLink = /* #__PURE__ */ $SymlinkType("FileLink");
+const DirLink = /* #__PURE__ */ $SymlinkType("DirLink");
+const JunctionLink = /* #__PURE__ */ $SymlinkType("JunctionLink");
+const symlinkTypeToNode = ty => {
+  if (ty === "FileLink") { return "file"; }
+  if (ty === "DirLink") { return "dir"; }
+  if (ty === "JunctionLink") { return "junction"; }
+  $runtime.fail();
+};
+const showSymlinkType = {
+  show: v => {
+    if (v === "FileLink") { return "FileLink"; }
+    if (v === "DirLink") { return "DirLink"; }
+    if (v === "JunctionLink") { return "JunctionLink"; }
+    $runtime.fail();
+  }
+};
+const eqSymlinkType = {
+  eq: x => y => {
+    if (x === "FileLink") { return y === "FileLink"; }
+    if (x === "DirLink") { return y === "DirLink"; }
+    return x === "JunctionLink" && y === "JunctionLink";
+  }
+};
+export {$SymlinkType, DirLink, FileLink, JunctionLink, eqSymlinkType, showSymlinkType, symlinkTypeToNode};

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

@@ -0,0 +1,132 @@
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+import * as Node$dFS$dAsync from "../Node.FS.Async/index.js";
+import * as Node$dFS$dConstants from "../Node.FS.Constants/index.js";
+const toAff1 = f => a => {
+  const $0 = f(a);
+  return Effect$dAff.makeAff(k => {
+    const $1 = $0(k);
+    return () => {
+      $1();
+      return Effect$dAff.nonCanceler;
+    };
+  });
+};
+const unlink = /* #__PURE__ */ toAff1(Node$dFS$dAsync.unlink);
+const toAff2 = f => a => b => {
+  const $0 = f(a)(b);
+  return Effect$dAff.makeAff(k => {
+    const $1 = $0(k);
+    return () => {
+      $1();
+      return Effect$dAff.nonCanceler;
+    };
+  });
+};
+const truncate = /* #__PURE__ */ toAff2(Node$dFS$dAsync.truncate);
+const writeFile = /* #__PURE__ */ toAff2(Node$dFS$dAsync.writeFile);
+const toAff3 = f => a => b => c => {
+  const $0 = f(a)(b)(c);
+  return Effect$dAff.makeAff(k => {
+    const $1 = $0(k);
+    return () => {
+      $1();
+      return Effect$dAff.nonCanceler;
+    };
+  });
+};
+const utimes = /* #__PURE__ */ toAff3(Node$dFS$dAsync.utimes);
+const writeTextFile = /* #__PURE__ */ toAff3(Node$dFS$dAsync.writeTextFile);
+const toAff5 = f => a => b => c => d => e => {
+  const $0 = f(a)(b)(c)(d)(e);
+  return Effect$dAff.makeAff(k => {
+    const $1 = $0(k);
+    return () => {
+      $1();
+      return Effect$dAff.nonCanceler;
+    };
+  });
+};
+const symlink = /* #__PURE__ */ toAff3(Node$dFS$dAsync.symlink);
+const stat = /* #__PURE__ */ toAff1(Node$dFS$dAsync.stat);
+const rmdir$p = /* #__PURE__ */ toAff2(Node$dFS$dAsync.rmdir$p);
+const rmdir = /* #__PURE__ */ toAff1(Node$dFS$dAsync.rmdir);
+const rm$p = /* #__PURE__ */ toAff2(Node$dFS$dAsync.rm$p);
+const rm = /* #__PURE__ */ toAff1(Node$dFS$dAsync.rmdir);
+const rename = /* #__PURE__ */ toAff2(Node$dFS$dAsync.rename);
+const realpath$p = /* #__PURE__ */ toAff2(Node$dFS$dAsync.realpath$p);
+const realpath = /* #__PURE__ */ toAff1(Node$dFS$dAsync.realpath);
+const readlink = /* #__PURE__ */ toAff1(Node$dFS$dAsync.readlink);
+const readdir = /* #__PURE__ */ toAff1(Node$dFS$dAsync.readdir);
+const readTextFile = /* #__PURE__ */ toAff2(Node$dFS$dAsync.readTextFile);
+const readFile = /* #__PURE__ */ toAff1(Node$dFS$dAsync.readFile);
+const mkdtemp$p = /* #__PURE__ */ toAff2(Node$dFS$dAsync.mkdtemp$p);
+const mkdtemp = /* #__PURE__ */ toAff1(Node$dFS$dAsync.mkdtemp);
+const mkdir$p = /* #__PURE__ */ toAff2(Node$dFS$dAsync.mkdir$p);
+const mkdir = /* #__PURE__ */ toAff1(Node$dFS$dAsync.mkdir);
+const link = /* #__PURE__ */ toAff2(Node$dFS$dAsync.link);
+const fdWrite = /* #__PURE__ */ toAff5(Node$dFS$dAsync.fdWrite);
+const fdRead = /* #__PURE__ */ toAff5(Node$dFS$dAsync.fdRead);
+const fdOpen = /* #__PURE__ */ toAff3(Node$dFS$dAsync.fdOpen);
+const fdNext = /* #__PURE__ */ toAff2(Node$dFS$dAsync.fdNext);
+const fdClose = /* #__PURE__ */ toAff1(Node$dFS$dAsync.fdClose);
+const fdAppend = /* #__PURE__ */ toAff2(Node$dFS$dAsync.fdAppend);
+const copyFile$p = /* #__PURE__ */ toAff3(Node$dFS$dAsync.copyFile$p);
+const copyFile = /* #__PURE__ */ toAff2(Node$dFS$dAsync.copyFile);
+const chown = /* #__PURE__ */ toAff3(Node$dFS$dAsync.chown);
+const chmod = /* #__PURE__ */ toAff2(Node$dFS$dAsync.chmod);
+const appendTextFile = /* #__PURE__ */ toAff3(Node$dFS$dAsync.appendTextFile);
+const appendFile = /* #__PURE__ */ toAff2(Node$dFS$dAsync.appendFile);
+const access$p = path => mode => Effect$dAff.makeAff(k => () => {
+  Node$dFS$dAsync.accessImpl(path, mode, err => k(Data$dEither.$Either("Right", Data$dNullable.nullable(err, Data$dMaybe.Nothing, Data$dMaybe.Just)))());
+  return Effect$dAff.nonCanceler;
+});
+const access = path => Effect$dAff.makeAff(k => () => {
+  Node$dFS$dAsync.accessImpl(path, Node$dFS$dConstants.f_OK, err => k(Data$dEither.$Either("Right", Data$dNullable.nullable(err, Data$dMaybe.Nothing, Data$dMaybe.Just)))());
+  return Effect$dAff.nonCanceler;
+});
+export {
+  access,
+  access$p,
+  appendFile,
+  appendTextFile,
+  chmod,
+  chown,
+  copyFile,
+  copyFile$p,
+  fdAppend,
+  fdClose,
+  fdNext,
+  fdOpen,
+  fdRead,
+  fdWrite,
+  link,
+  mkdir,
+  mkdir$p,
+  mkdtemp,
+  mkdtemp$p,
+  readFile,
+  readTextFile,
+  readdir,
+  readlink,
+  realpath,
+  realpath$p,
+  rename,
+  rm,
+  rm$p,
+  rmdir,
+  rmdir$p,
+  stat,
+  symlink,
+  toAff1,
+  toAff2,
+  toAff3,
+  toAff5,
+  truncate,
+  unlink,
+  utimes,
+  writeFile,
+  writeTextFile
+};

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

@@ -0,0 +1,28 @@
+export {
+  access as accessImpl,
+  copyFile as copyFileImpl,
+  mkdtemp as mkdtempImpl,
+  rename as renameImpl,
+  truncate as truncateImpl,
+  chown as chownImpl,
+  chmod as chmodImpl,
+  stat as statImpl,
+  lstat as lstatImpl,
+  link as linkImpl,
+  symlink as symlinkImpl,
+  readlink as readlinkImpl,
+  realpath as realpathImpl,
+  unlink as unlinkImpl,
+  rmdir as rmdirImpl,
+  rm as rmImpl,
+  mkdir as mkdirImpl,
+  readdir as readdirImpl,
+  utimes as utimesImpl,
+  readFile as readFileImpl,
+  writeFile as writeFileImpl,
+  appendFile as appendFileImpl,
+  open as openImpl,
+  read as readImpl,
+  write as writeImpl,
+  close as closeImpl
+} from "node:fs";

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

@@ -0,0 +1,241 @@
+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 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,
+  appendFileImpl,
+  chmodImpl,
+  chownImpl,
+  closeImpl,
+  copyFileImpl,
+  linkImpl,
+  lstatImpl,
+  mkdirImpl,
+  mkdtempImpl,
+  openImpl,
+  readFileImpl,
+  readImpl,
+  readdirImpl,
+  readlinkImpl,
+  realpathImpl,
+  renameImpl,
+  rmImpl,
+  rmdirImpl,
+  statImpl,
+  symlinkImpl,
+  truncateImpl,
+  unlinkImpl,
+  utimesImpl,
+  writeFileImpl,
+  writeImpl
+} from "./foreign.js";
+const handleCallback = cb => (err, a) => {
+  const v = Data$dNullable.nullable(err, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  if (v.tag === "Nothing") { return cb(Data$dEither.$Either("Right", a))(); }
+  if (v.tag === "Just") { return cb(Data$dEither.$Either("Left", v._1))(); }
+  $runtime.fail();
+};
+const link = src => dst => cb => () => linkImpl(src, dst, handleCallback(cb));
+const lstat = file => cb => () => lstatImpl(file, handleCallback(cb));
+const mkdir$p = file => v => cb => {
+  const $0 = {recursive: v.recursive, mode: Node$dFS$dPerms.permsToString(v.mode)};
+  return () => mkdirImpl(file, $0, handleCallback(cb));
+};
+const mkdir = path => mkdir$p(path)({recursive: false, mode: {u: Node$dFS$dPerms.semiringPerm.one, g: Node$dFS$dPerms.semiringPerm.one, o: Node$dFS$dPerms.semiringPerm.one}});
+const mkdtemp$p = prefix => encoding => cb => {
+  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, handleCallback(cb));
+};
+const mkdtemp = prefix => mkdtemp$p(prefix)(Node$dEncoding.UTF8);
+const readFile = file => cb => () => readFileImpl(file, {}, handleCallback(cb));
+const readTextFile = encoding => file => cb => {
+  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 () => readFileImpl(file, $0, handleCallback(cb));
+};
+const readdir = file => cb => () => readdirImpl(file, handleCallback(cb));
+const readlink = path => cb => () => readlinkImpl(path, handleCallback(cb));
+const realpath = path => cb => () => realpathImpl(path, {}, handleCallback(cb));
+const realpath$p = path => cache => cb => () => realpathImpl(path, cache, handleCallback(cb));
+const rename = oldFile => newFile => cb => () => renameImpl(oldFile, newFile, handleCallback(cb));
+const rm$p = path => opts => cb => () => rmImpl(path, opts, handleCallback(cb));
+const rm = path => rm$p(path)({force: false, maxRetries: 100, recursive: false, retryDelay: 1000});
+const rmdir$p = path => opts => cb => () => rmdirImpl(path, opts, handleCallback(cb));
+const rmdir = path => cb => () => rmdirImpl(path, {maxRetries: 0, retryDelay: 100}, handleCallback(cb));
+const stat = file => cb => () => statImpl(file, handleCallback(cb));
+const symlink = src => dest => ty => cb => {
+  const $0 = (() => {
+    if (ty === "FileLink") { return "file"; }
+    if (ty === "DirLink") { return "dir"; }
+    if (ty === "JunctionLink") { return "junction"; }
+    $runtime.fail();
+  })();
+  return () => symlinkImpl(src, dest, $0, handleCallback(cb));
+};
+const truncate = file => len => cb => () => truncateImpl(file, len, handleCallback(cb));
+const unlink = file => cb => () => unlinkImpl(file, handleCallback(cb));
+const utimes = file => atime => mtime => cb => {
+  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 () => utimesImpl(file, $0, $1, handleCallback(cb));
+};
+const writeFile = file => buff => cb => () => writeFileImpl(file, buff, {}, handleCallback(cb));
+const writeTextFile = encoding => file => buff => cb => {
+  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 () => writeFileImpl(file, buff, $0, handleCallback(cb));
+};
+const fdWrite = fd => buff => off => len => pos => cb => {
+  const $0 = (() => {
+    if (pos.tag === "Nothing") { return Data$dNullable.null; }
+    if (pos.tag === "Just") { return Data$dNullable.notNull(pos._1); }
+    $runtime.fail();
+  })();
+  return () => writeImpl(fd, buff, off, len, $0, handleCallback(cb));
+};
+const fdRead = fd => buff => off => len => pos => cb => {
+  const $0 = (() => {
+    if (pos.tag === "Nothing") { return Data$dNullable.null; }
+    if (pos.tag === "Just") { return Data$dNullable.notNull(pos._1); }
+    $runtime.fail();
+  })();
+  return () => readImpl(fd, buff, off, len, $0, handleCallback(cb));
+};
+const fdOpen = file => flags => mode => cb => {
+  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 () => openImpl(file, $0, $1, handleCallback(cb));
+};
+const fdNext = fd => buff => cb => () => fdRead(fd)(buff)(0)(Node$dBuffer$dImmutable.size(buff))(Data$dMaybe.Nothing)(cb)();
+const fdClose = fd => cb => () => closeImpl(fd, handleCallback(cb));
+const fdAppend = fd => buff => cb => () => fdWrite(fd)(buff)(0)(Node$dBuffer$dImmutable.size(buff))(Data$dMaybe.Nothing)(cb)();
+const copyFile$p = src => dest => mode => cb => () => copyFileImpl(src, dest, mode, handleCallback(cb));
+const copyFile = src => dest => copyFile$p(src)(dest)(Node$dFS$dConstants.copyFile_EXCL);
+const chown = file => uid => gid => cb => () => chownImpl(file, uid, gid, handleCallback(cb));
+const chmod = file => perms => cb => {
+  const $0 = Node$dFS$dPerms.permsToString(perms);
+  return () => chmodImpl(file, $0, handleCallback(cb));
+};
+const appendTextFile = encoding => file => buff => cb => {
+  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 () => appendFileImpl(file, buff, $0, handleCallback(cb));
+};
+const appendFile = file => buff => cb => () => appendFileImpl(file, buff, {}, handleCallback(cb));
+const access$p = path => mode => cb => () => accessImpl(path, mode, err => cb(Data$dNullable.nullable(err, Data$dMaybe.Nothing, Data$dMaybe.Just))());
+const access = path => access$p(path)(Node$dFS$dConstants.f_OK);
+export {
+  access,
+  access$p,
+  appendFile,
+  appendTextFile,
+  chmod,
+  chown,
+  copyFile,
+  copyFile$p,
+  fdAppend,
+  fdClose,
+  fdNext,
+  fdOpen,
+  fdRead,
+  fdWrite,
+  handleCallback,
+  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";

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

@@ -0,0 +1,17 @@
+import { constants } from "node:fs";
+
+export const f_OK = constants.F_OK;
+
+export const r_OK = constants.R_OK;
+
+export const w_OK = constants.W_OK;
+
+export const x_OK = constants.X_OK;
+
+export const copyFile_EXCL = constants.COPYFILE_EXCL;
+
+export const copyFile_FICLONE = constants.COPYFILE_FICLONE;
+
+export const copyFile_FICLONE_FORCE = constants.COPYFILE_FICLONE_FORCE;
+
+export const appendCopyMode = (l, r) => l | r;