elit 2.0.1 → 3.0.0

package/dist/fs.js

@@ -0,0 +1,513 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/fs.ts
+var fs_exports = {};
+__export(fs_exports, {
+  appendFile: () => appendFile,
+  appendFileSync: () => appendFileSync,
+  copyFile: () => copyFile,
+  copyFileSync: () => copyFileSync,
+  default: () => fs_default,
+  exists: () => exists,
+  existsSync: () => existsSync,
+  getRuntime: () => getRuntime,
+  mkdir: () => mkdir,
+  mkdirSync: () => mkdirSync,
+  promises: () => promises,
+  readFile: () => readFile,
+  readFileSync: () => readFileSync,
+  readdir: () => readdir,
+  readdirSync: () => readdirSync,
+  realpath: () => realpath,
+  realpathSync: () => realpathSync,
+  rename: () => rename,
+  renameSync: () => renameSync,
+  rmdir: () => rmdir,
+  rmdirSync: () => rmdirSync,
+  stat: () => stat,
+  statSync: () => statSync,
+  unlink: () => unlink,
+  unlinkSync: () => unlinkSync,
+  writeFile: () => writeFile,
+  writeFileSync: () => writeFileSync
+});
+module.exports = __toCommonJS(fs_exports);
+
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/fs.ts
+var isBunOrDeno = isBun || isDeno;
+function parseOptions(options, defaultValue) {
+  return typeof options === "string" ? { encoding: options } : options || defaultValue;
+}
+function decodeContent(content, encoding) {
+  if (encoding) {
+    return new TextDecoder(encoding).decode(content);
+  }
+  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
+}
+function dataToUint8Array(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Buffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+function processDenoEntries(iterator, withFileTypes) {
+  const entries = [];
+  for (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+async function processDenoEntriesAsync(iterator, withFileTypes) {
+  const entries = [];
+  for await (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+var fs;
+var fsPromises;
+if (isNode) {
+  fs = require("fs");
+  fsPromises = require("fs/promises");
+}
+async function readFile(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.readFile(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = await file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = await Deno.readFile(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readFileSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readFileSync(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = Deno.readFileSync(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function writeFile(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.writeFile(path, data, opts);
+  } else if (isBun) {
+    await Bun.write(path, data);
+  } else if (isDeno) {
+    await Deno.writeFile(path, dataToUint8Array(data));
+  }
+}
+function writeFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.writeFileSync(path, data, opts);
+  } else if (isBun) {
+    Bun.write(path, data);
+  } else if (isDeno) {
+    Deno.writeFileSync(path, dataToUint8Array(data));
+  }
+}
+async function appendFile(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.appendFile(path, data, opts);
+  } else {
+    if (await exists(path)) {
+      const existing = await readFile(path);
+      const combined = Buffer.isBuffer(existing) ? Buffer.concat([existing, Buffer.isBuffer(data) ? data : Buffer.from(data)]) : existing + (Buffer.isBuffer(data) ? data.toString() : data);
+      await writeFile(path, combined, opts);
+    } else {
+      await writeFile(path, data, opts);
+    }
+  }
+}
+function appendFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.appendFileSync(path, data, opts);
+  } else {
+    if (existsSync(path)) {
+      const existing = readFileSync(path);
+      const combined = Buffer.isBuffer(existing) ? Buffer.concat([existing, Buffer.isBuffer(data) ? data : Buffer.from(data)]) : existing + (Buffer.isBuffer(data) ? data.toString() : data);
+      writeFileSync(path, combined, opts);
+    } else {
+      writeFileSync(path, data, opts);
+    }
+  }
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function existsSync(path) {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stat(path) {
+  if (isNode) {
+    return fsPromises.stat(path);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const size = file.size;
+    const exists2 = await file.exists();
+    if (!exists2) {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return createStatsObject(path, size, false);
+  } else if (isDeno) {
+    const info = await Deno.stat(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+function statSync(path) {
+  if (isNode) {
+    return fs.statSync(path);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const size = file.size;
+    try {
+      file.arrayBuffer();
+    } catch {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return createStatsObject(path, size, false);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function mkdir(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode) {
+    await fsPromises.mkdir(path, opts);
+  } else if (isBun) {
+    await Deno.mkdir(path, { recursive: opts.recursive });
+  } else if (isDeno) {
+    await Deno.mkdir(path, { recursive: opts.recursive });
+  }
+}
+function mkdirSync(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode) {
+    fs.mkdirSync(path, opts);
+  } else if (isBun) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  } else if (isDeno) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  }
+}
+async function readdir(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.readdir(path, opts);
+  } else if (isBunOrDeno) {
+    return processDenoEntriesAsync(Deno.readDir(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readdirSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readdirSync(path, opts);
+  } else if (isBunOrDeno) {
+    return processDenoEntries(Deno.readDirSync(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function unlink(path) {
+  if (isNode) {
+    return fsPromises.unlink(path);
+  } else if (isBun) {
+    await Deno.remove(path);
+  } else if (isDeno) {
+    await Deno.remove(path);
+  }
+}
+function unlinkSync(path) {
+  if (isNode) {
+    fs.unlinkSync(path);
+  } else if (isBun) {
+    Deno.removeSync(path);
+  } else if (isDeno) {
+    Deno.removeSync(path);
+  }
+}
+async function rmdir(path, options) {
+  if (isNode) {
+    return fsPromises.rmdir(path, options);
+  } else if (isBun) {
+    await Deno.remove(path, { recursive: options?.recursive });
+  } else if (isDeno) {
+    await Deno.remove(path, { recursive: options?.recursive });
+  }
+}
+function rmdirSync(path, options) {
+  if (isNode) {
+    fs.rmdirSync(path, options);
+  } else if (isBun) {
+    Deno.removeSync(path, { recursive: options?.recursive });
+  } else if (isDeno) {
+    Deno.removeSync(path, { recursive: options?.recursive });
+  }
+}
+async function rename(oldPath, newPath) {
+  if (isNode) {
+    return fsPromises.rename(oldPath, newPath);
+  } else if (isBun) {
+    await Deno.rename(oldPath, newPath);
+  } else if (isDeno) {
+    await Deno.rename(oldPath, newPath);
+  }
+}
+function renameSync(oldPath, newPath) {
+  if (isNode) {
+    fs.renameSync(oldPath, newPath);
+  } else if (isBun) {
+    Deno.renameSync(oldPath, newPath);
+  } else if (isDeno) {
+    Deno.renameSync(oldPath, newPath);
+  }
+}
+async function copyFile(src, dest, flags) {
+  if (isNode) {
+    return fsPromises.copyFile(src, dest, flags);
+  } else if (isBun) {
+    await Deno.copyFile(src, dest);
+  } else if (isDeno) {
+    await Deno.copyFile(src, dest);
+  }
+}
+function copyFileSync(src, dest, flags) {
+  if (isNode) {
+    fs.copyFileSync(src, dest, flags);
+  } else if (isBun) {
+    Deno.copyFileSync(src, dest);
+  } else if (isDeno) {
+    Deno.copyFileSync(src, dest);
+  }
+}
+async function realpath(path, options) {
+  if (isNode) {
+    return fsPromises.realpath(path, options);
+  } else if (isBun) {
+    const fs2 = require("fs/promises");
+    return fs2.realpath(path, options);
+  } else if (isDeno) {
+    return await Deno.realPath(path);
+  }
+  return path;
+}
+function realpathSync(path, options) {
+  if (isNode) {
+    return fs.realpathSync(path, options);
+  } else if (isBun) {
+    const fs2 = require("fs");
+    return fs2.realpathSync(path, options);
+  } else if (isDeno) {
+    return Deno.realPathSync(path);
+  }
+  return path;
+}
+function createStatsObject(_path, size, isDir) {
+  const now = Date.now();
+  return {
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: 0,
+    ino: 0,
+    mode: isDir ? 16877 : 33188,
+    nlink: 1,
+    uid: 0,
+    gid: 0,
+    rdev: 0,
+    size,
+    blksize: 4096,
+    blocks: Math.ceil(size / 512),
+    atimeMs: now,
+    mtimeMs: now,
+    ctimeMs: now,
+    birthtimeMs: now,
+    atime: new Date(now),
+    mtime: new Date(now),
+    ctime: new Date(now),
+    birthtime: new Date(now)
+  };
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
+function createDirentFromDenoEntry(entry) {
+  return {
+    name: entry.name,
+    isFile: () => entry.isFile,
+    isDirectory: () => entry.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => entry.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false
+  };
+}
+function getRuntime() {
+  return runtime;
+}
+var promises = {
+  readFile,
+  writeFile,
+  appendFile,
+  stat,
+  mkdir,
+  readdir,
+  unlink,
+  rmdir,
+  rename,
+  copyFile,
+  realpath
+};
+var fs_default = {
+  readFile,
+  readFileSync,
+  writeFile,
+  writeFileSync,
+  appendFile,
+  appendFileSync,
+  exists,
+  existsSync,
+  stat,
+  statSync,
+  mkdir,
+  mkdirSync,
+  readdir,
+  readdirSync,
+  unlink,
+  unlinkSync,
+  rmdir,
+  rmdirSync,
+  rename,
+  renameSync,
+  copyFile,
+  copyFileSync,
+  realpath,
+  realpathSync,
+  promises,
+  getRuntime
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendFile,
+  appendFileSync,
+  copyFile,
+  copyFileSync,
+  exists,
+  existsSync,
+  getRuntime,
+  mkdir,
+  mkdirSync,
+  promises,
+  readFile,
+  readFileSync,
+  readdir,
+  readdirSync,
+  realpath,
+  realpathSync,
+  rename,
+  renameSync,
+  rmdir,
+  rmdirSync,
+  stat,
+  statSync,
+  unlink,
+  unlinkSync,
+  writeFile,
+  writeFileSync
+});