@gjsify/fs 0.0.1 → 0.0.2

package/lib/cjs/promises.js

@@ -0,0 +1,189 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var promises_exports = {};
+__export(promises_exports, {
+  default: () => promises_default,
+  lstat: () => import_fs_lstat.lstatPromise,
+  mkdir: () => mkdir,
+  mkdtemp: () => mkdtemp,
+  open: () => open,
+  readFile: () => readFile,
+  readdir: () => import_fs_readdir.readdirPromise,
+  realpath: () => import_fs_realpath.realpathPromise,
+  rm: () => rm,
+  rmdir: () => rmdir,
+  stat: () => import_fs_stat.statPromise,
+  symlink: () => import_fs_symlink.symlinkPromise,
+  unlink: () => unlink,
+  write: () => write,
+  writeFile: () => writeFile
+});
+module.exports = __toCommonJS(promises_exports);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+var import_utils = require("@gjsify/utils");
+var import_path = require("path");
+var import_encoding = require("./encoding.js");
+var import_sync = require("./sync.js");
+var import_file_handle = require("./file-handle.js");
+var import_utils2 = require("./utils.js");
+var import_dirent = require("./dirent.js");
+var import_fs_realpath = require("@gjsify/deno_std/node/_fs/_fs_realpath");
+var import_fs_readdir = require("@gjsify/deno_std/node/_fs/_fs_readdir");
+var import_fs_symlink = require("@gjsify/deno_std/node/_fs/_fs_symlink");
+var import_fs_lstat = require("@gjsify/deno_std/node/_fs/_fs_lstat");
+var import_fs_stat = require("@gjsify/deno_std/node/_fs/_fs_stat");
+async function mkdir(path, options) {
+  let recursive;
+  let mode = 511;
+  if (typeof options === "object") {
+    if (options.recursive)
+      recursive = options.recursive;
+    if (options.mode)
+      mode = options.mode;
+  } else {
+    mode = options;
+  }
+  const firstPath = (0, import_sync.mkdirSync)(path, {
+    recursive,
+    mode
+  });
+  return firstPath;
+}
+async function readFile(path, options = { encoding: null, flag: "r" }) {
+  const file = import_gio_2.default.File.new_for_path(path.toString());
+  const [ok, data] = await new Promise((resolve, reject) => {
+    file.load_contents_async(null, (self, res) => {
+      try {
+        resolve(file.load_contents_finish(res));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+  if (!ok) {
+    throw new Error("failed to read file");
+  }
+  return (0, import_encoding.encodeUint8Array)((0, import_encoding.getEncodingFromOptions)(options, "buffer"), data);
+}
+async function mkdtemp(prefix, options) {
+  const encoding = (0, import_encoding.getEncodingFromOptions)(options);
+  const path = (0, import_utils2.tempDirPath)(prefix);
+  await mkdir(
+    path,
+    { recursive: false, mode: 448 }
+  );
+  return (0, import_encoding.decode)(path, encoding);
+}
+async function writeFile(path, data) {
+  return (0, import_sync.writeFileSync)(path, data);
+}
+async function rmdir(path, options) {
+  return (0, import_sync.rmdirSync)(path, options);
+}
+async function unlink(path) {
+  return (0, import_sync.unlinkSync)(path);
+}
+async function open(path, flags, mode) {
+  return new import_file_handle.FileHandle({
+    path,
+    flags,
+    mode
+  });
+}
+async function write(fd, data, positionOrOffset, encodingOrLength, position) {
+  if (typeof data === "string") {
+    return _writeStr(fd, data, positionOrOffset, encodingOrLength);
+  }
+  return _writeBuf(fd, data, positionOrOffset, encodingOrLength, position);
+}
+async function _writeBuf(fd, buffer, offset, length, position) {
+  (0, import_utils.warnNotImplemented)("fs.promises.write");
+  return {
+    bytesWritten: 0,
+    buffer
+  };
+}
+async function _writeStr(fd, data, position, encoding) {
+  (0, import_utils.warnNotImplemented)("fs.promises.write");
+  return {
+    bytesWritten: 0,
+    buffer: data
+  };
+}
+async function rm(path, options) {
+  const file = import_gio_2.default.File.new_for_path(path.toString());
+  const recursive = options?.recursive || false;
+  const dirent = new import_dirent.Dirent(path.toString());
+  if (dirent.isDirectory()) {
+    const childFiles = await (0, import_fs_readdir.readdirPromise)(path, { withFileTypes: true });
+    if (!recursive && childFiles.length) {
+      throw new Error("Dir is not empty!");
+    }
+    for (const childFile of childFiles) {
+      if (childFile.isDirectory()) {
+        await rmdir((0, import_path.join)(path.toString(), childFile.name), options);
+      } else if (childFile.isFile()) {
+        await rm((0, import_path.join)(path.toString(), childFile.name), options);
+      }
+    }
+  }
+  const ok = await new Promise((resolve, reject) => {
+    try {
+      file.delete_async(import_glib_2.default.PRIORITY_DEFAULT, null, (self, res) => {
+        try {
+          resolve(file.delete_finish(res));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+  if (!ok) {
+    const err = new Error("failed to remove file " + path);
+    throw err;
+  }
+}
+var promises_default = {
+  readFile,
+  mkdir,
+  mkdtemp,
+  realpath: import_fs_realpath.realpathPromise,
+  readdir: import_fs_readdir.readdirPromise,
+  writeFile,
+  rmdir,
+  unlink,
+  open,
+  write,
+  rm,
+  lstat: import_fs_lstat.lstatPromise,
+  symlink: import_fs_symlink.symlinkPromise,
+  stat: import_fs_stat.statPromise
+};

package/lib/cjs/read-stream.js

@@ -0,0 +1,107 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var read_stream_exports = {};
+__export(read_stream_exports, {
+  ReadStream: () => ReadStream,
+  createReadStream: () => createReadStream,
+  fromFileUrl: () => fromFileUrl
+});
+module.exports = __toCommonJS(read_stream_exports);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+var import_utils = require("@gjsify/utils");
+var import_buffer = require("buffer");
+var import_stream = require("stream");
+var import_url = require("url");
+function fromFileUrl(url) {
+  url = url instanceof import_url.URL ? url : new import_url.URL(url);
+  if (url.protocol != "file:") {
+    throw new TypeError("Must be a file URL.");
+  }
+  return decodeURIComponent(
+    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25")
+  );
+}
+class ReadStream extends import_stream.Readable {
+  close(callback) {
+    callback((0, import_utils.notImplemented)("ReadStream.close"));
+  }
+  /**
+   * The number of bytes that have been read so far.
+   * @since v6.4.0
+   */
+  bytesRead;
+  /**
+   * The path to the file the stream is reading from as specified in the first
+   * argument to `fs.createReadStream()`. If `path` is passed as a string, then`readStream.path` will be a string. If `path` is passed as a `Buffer`, then`readStream.path` will be a
+   * `Buffer`. If `fd` is specified, then`readStream.path` will be `undefined`.
+   * @since v0.1.93
+   */
+  path;
+  /**
+   * This property is `true` if the underlying file has not been opened yet,
+   * i.e. before the `'ready'` event is emitted.
+   * @since v11.2.0, v10.16.0
+   */
+  pending;
+  constructor(path, opts) {
+    path = path instanceof import_url.URL ? fromFileUrl(path) : path;
+    const hasBadOptions = opts && (opts.start || opts.end);
+    if (hasBadOptions) {
+      (0, import_utils.notImplemented)(
+        `fs.ReadStream.prototype.constructor with unsupported options (${JSON.stringify(opts)})`
+      );
+    }
+    const file = import_glib_2.default.IOChannel.new_file(path.toString(), "r");
+    const buffer = "";
+    super({
+      autoDestroy: true,
+      emitClose: true,
+      objectMode: false,
+      read: async function(_size) {
+        try {
+          let n = 0;
+          file.read(buffer, 16 * 1024, n);
+          this.push(n ? import_buffer.Buffer.from(buffer.slice(0, n)) : null);
+        } catch (err) {
+          this.destroy(err);
+        }
+      },
+      destroy: (err, cb) => {
+        try {
+          file.close();
+        } catch {
+        }
+        cb(err);
+      }
+    });
+    this.path = path.toString();
+  }
+}
+function createReadStream(path, options) {
+  return new ReadStream(path, options);
+}

package/lib/cjs/stats.js

@@ -0,0 +1,74 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stats_exports = {};
+__export(stats_exports, {
+  Stats: () => Stats
+});
+module.exports = __toCommonJS(stats_exports);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+var import_dirent = require("./dirent.js");
+var import_path = require("path");
+class Stats extends import_dirent.Dirent {
+  dev;
+  ino;
+  mode;
+  nlink;
+  uid;
+  gid;
+  rdev;
+  size;
+  blksize;
+  blocks;
+  atimeMs;
+  mtimeMs;
+  ctimeMs;
+  /** The timestamp indicating the creation time of this file expressed in milliseconds since the POSIX Epoch. */
+  get birthtimeMs() {
+    const creationDateTime = this._info.get_creation_date_time();
+    return creationDateTime.get_microsecond() * 1e3;
+  }
+  atime;
+  mtime;
+  ctime;
+  /** The timestamp indicating the creation time of this file. */
+  get birthtime() {
+    const creationDateTime = this._info.get_creation_date_time();
+    return new Date(creationDateTime.format_iso8601());
+  }
+  _info;
+  constructor(path, filename) {
+    const pathStr = path.toString();
+    if (!filename)
+      filename = (0, import_path.basename)(pathStr);
+    super(pathStr, filename);
+    if (!this._file) {
+      throw new TypeError("this._file is not defined!");
+    }
+    this._info = this._file.query_info("standard::", import_gio_2.default.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+  }
+}

package/lib/cjs/sync.js

@@ -0,0 +1,155 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sync_exports = {};
+__export(sync_exports, {
+  existsSync: () => import_utils.existsSync,
+  lstatSync: () => import_fs_lstat.lstatSync,
+  mkdirSync: () => mkdirSync,
+  mkdtempSync: () => mkdtempSync,
+  openSync: () => openSync,
+  readFileSync: () => readFileSync,
+  readdirSync: () => import_fs_readdir.readdirSync,
+  realpathSync: () => import_fs_realpath.realpathSync,
+  rmSync: () => rmSync,
+  rmdirSync: () => rmdirSync,
+  statSync: () => import_fs_stat.statSync,
+  symlinkSync: () => import_fs_symlink.symlinkSync,
+  unlinkSync: () => unlinkSync,
+  watch: () => watch,
+  writeFileSync: () => writeFileSync
+});
+module.exports = __toCommonJS(sync_exports);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+var import_utils = require("@gjsify/utils");
+var import_path = require("path");
+var import_fs_watcher = __toESM(require("./fs-watcher.js"), 1);
+var import_encoding = require("./encoding.js");
+var import_file_handle = require("./file-handle.js");
+var import_dirent = require("./dirent.js");
+var import_utils2 = require("./utils.js");
+var import_fs_realpath = require("@gjsify/deno_std/node/_fs/_fs_realpath");
+var import_fs_readdir = require("@gjsify/deno_std/node/_fs/_fs_readdir");
+var import_fs_symlink = require("@gjsify/deno_std/node/_fs/_fs_symlink");
+var import_fs_lstat = require("@gjsify/deno_std/node/_fs/_fs_lstat");
+var import_fs_stat = require("@gjsify/deno_std/node/_fs/_fs_stat");
+function readFileSync(path, options = { encoding: null, flag: "r" }) {
+  const file = import_gio_2.default.File.new_for_path(path);
+  const [ok, data] = file.load_contents(null);
+  if (!ok) {
+    throw new Error("failed to read file");
+  }
+  return (0, import_encoding.encodeUint8Array)((0, import_encoding.getEncodingFromOptions)(options, "buffer"), data);
+}
+function mkdirSync(path, options) {
+  let recursive = false;
+  let mode = 511;
+  if (typeof options === "object") {
+    if (options?.recursive)
+      recursive = options.recursive;
+    if (options?.mode)
+      mode = options.mode;
+  } else {
+    mode = options || 511;
+  }
+  if (typeof path !== "string") {
+    path = path.toString();
+  }
+  if (typeof mode === "string") {
+    throw new TypeError("mode as string is currently not supported!");
+  }
+  if (import_glib_2.default.mkdir_with_parents(path, mode) !== 0) {
+    throw new Error(`failed to make ${path} directory`);
+  }
+  if (recursive) {
+    return path.split("/")[0];
+  }
+  return void 0;
+}
+function rmdirSync(path, options) {
+  const recursive = options?.recursive || false;
+  const childFiles = (0, import_fs_readdir.readdirSync)(path, { withFileTypes: true });
+  if (!recursive && childFiles.length) {
+    throw new Error("Dir is not empty!");
+  }
+  for (const childFile of childFiles) {
+    if (childFile.isDirectory()) {
+      rmdirSync((0, import_path.join)(path.toString(), childFile.name));
+    } else if (childFile.isFile()) {
+      rmSync((0, import_path.join)(path.toString(), childFile.name));
+    }
+  }
+  const result = import_glib_2.default.rmdir(path.toString());
+  if (result !== 0) {
+    throw new Error(`Failed to remove ${path} directory`);
+  }
+}
+function unlinkSync(path) {
+  import_glib_2.default.unlink(path);
+}
+function writeFileSync(path, data) {
+  import_glib_2.default.file_set_contents(path, data);
+}
+function watch(filename, options, listener) {
+  return new import_fs_watcher.default(filename, options, listener);
+}
+function openSync(path, flags, mode) {
+  return new import_file_handle.FileHandle({ path, flags, mode });
+}
+function mkdtempSync(prefix, options) {
+  const encoding = (0, import_encoding.getEncodingFromOptions)(options);
+  const path = (0, import_utils2.tempDirPath)(prefix);
+  mkdirSync(
+    path,
+    { recursive: false, mode: 511 }
+  );
+  return (0, import_encoding.decode)(path, encoding);
+}
+function rmSync(path, options) {
+  const file = import_gio_2.default.File.new_for_path(path.toString());
+  const recursive = options?.recursive || false;
+  const dirent = new import_dirent.Dirent(path.toString());
+  if (dirent.isDirectory()) {
+    const childFiles = (0, import_fs_readdir.readdirSync)(path, { withFileTypes: true });
+    if (!recursive && childFiles.length) {
+      throw new Error("Dir is not empty!");
+    }
+    for (const childFile of childFiles) {
+      if (childFile.isDirectory()) {
+        rmdirSync((0, import_path.join)(path.toString(), childFile.name), options);
+      } else if (childFile.isFile()) {
+        rmSync((0, import_path.join)(path.toString(), childFile.name), options);
+      }
+    }
+  }
+  const ok = file.delete(null);
+  if (!ok) {
+    const err = new Error("failed to remove file " + path);
+    throw err;
+  }
+}

package/lib/cjs/types/encoding-option.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var encoding_option_exports = {};
+module.exports = __toCommonJS(encoding_option_exports);

package/lib/cjs/types/file-read-options.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_read_options_exports = {};
+module.exports = __toCommonJS(file_read_options_exports);

package/lib/cjs/types/file-read-result.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_read_result_exports = {};
+module.exports = __toCommonJS(file_read_result_exports);

package/lib/cjs/types/flag-and-open-mode.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var flag_and_open_mode_exports = {};
+module.exports = __toCommonJS(flag_and_open_mode_exports);

package/lib/cjs/types/index.js

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./encoding-option.js"), module.exports);
+__reExport(types_exports, require("./file-read-options.js"), module.exports);
+__reExport(types_exports, require("./file-read-result.js"), module.exports);
+__reExport(types_exports, require("./flag-and-open-mode.js"), module.exports);
+__reExport(types_exports, require("./open-flags.js"), module.exports);
+__reExport(types_exports, require("./read-options.js"), module.exports);

package/lib/cjs/types/open-flags.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var open_flags_exports = {};
+module.exports = __toCommonJS(open_flags_exports);

package/lib/cjs/types/read-options.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var read_options_exports = {};
+module.exports = __toCommonJS(read_options_exports);