elit 3.2.4 → 3.2.6

package/dist/config.js

@@ -0,0 +1,990 @@
+"use strict";
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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);
+
+// src/runtime.ts
+var runtime, isNode, isBun, isDeno;
+var init_runtime = __esm({
+  "src/runtime.ts"() {
+    "use strict";
+    runtime = (() => {
+      if (typeof Deno !== "undefined") return "deno";
+      if (typeof Bun !== "undefined") return "bun";
+      return "node";
+    })();
+    isNode = runtime === "node";
+    isBun = runtime === "bun";
+    isDeno = runtime === "deno";
+  }
+});
+
+// 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
+});
+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;
+}
+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 isBunOrDeno, fs, fsPromises, promises, fs_default;
+var init_fs = __esm({
+  "src/fs.ts"() {
+    "use strict";
+    init_runtime();
+    isBunOrDeno = isBun || isDeno;
+    if (isNode) {
+      fs = require("fs");
+      fsPromises = require("fs/promises");
+    }
+    promises = {
+      readFile,
+      writeFile,
+      appendFile,
+      stat,
+      mkdir,
+      readdir,
+      unlink,
+      rmdir,
+      rename,
+      copyFile,
+      realpath
+    };
+    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
+    };
+  }
+});
+
+// src/path.ts
+var path_exports = {};
+__export(path_exports, {
+  basename: () => basename,
+  default: () => path_default,
+  delimiter: () => delimiter,
+  dirname: () => dirname,
+  extname: () => extname,
+  format: () => format,
+  getRuntime: () => getRuntime2,
+  isAbsolute: () => isAbsolute,
+  join: () => join,
+  normalize: () => normalize,
+  parse: () => parse,
+  posix: () => posix,
+  relative: () => relative,
+  resolve: () => resolve,
+  sep: () => sep,
+  toNamespacedPath: () => toNamespacedPath,
+  win32: () => win32
+});
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  } else if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+function findLastSeparator(path) {
+  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+}
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+function isAbsolutePosix(path) {
+  return path.length > 0 && path[0] === "/";
+}
+function isAbsoluteWin(path) {
+  const len = path.length;
+  if (len === 0) return false;
+  const code = path.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function normalizePath(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const isAbsolute2 = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+  const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
+  let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const parts = normalized.split(separator);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "" || part === ".") {
+      if (i === 0 && isAbsolute2) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute2) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let final = result.join(separator);
+  if (final.length === 0) {
+    return isAbsolute2 ? separator : ".";
+  }
+  if (trailingSeparator && final[final.length - 1] !== separator) {
+    final += separator;
+  }
+  return final;
+}
+function joinPaths(paths, isWin) {
+  if (paths.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  let joined = "";
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      if (joined.length === 0) {
+        joined = path;
+      } else {
+        joined += separator + path;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, isWin);
+}
+function resolvePaths(paths, isWin) {
+  const separator = getSeparator(isWin);
+  let resolved = "";
+  let isAbsolute2 = false;
+  for (let i = paths.length - 1; i >= 0 && !isAbsolute2; i--) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+      isAbsolute2 = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!isAbsolute2) {
+    const cwd = getCwd();
+    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  }
+  return normalizePath(resolved, isWin);
+}
+function relativePath(from, to, isWin) {
+  from = resolvePaths([from], isWin);
+  to = resolvePaths([to], isWin);
+  if (from === to) return "";
+  const separator = getSeparator(isWin);
+  const fromParts = from.split(separator).filter((p) => p.length > 0);
+  const toParts = to.split(separator).filter((p) => p.length > 0);
+  let commonLength = 0;
+  const minLength = Math.min(fromParts.length, toParts.length);
+  for (let i = 0; i < minLength; i++) {
+    if (fromParts[i] === toParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const upCount = fromParts.length - commonLength;
+  const result = [];
+  for (let i = 0; i < upCount; i++) {
+    result.push("..");
+  }
+  for (let i = commonLength; i < toParts.length; i++) {
+    result.push(toParts[i]);
+  }
+  return result.join(separator) || ".";
+}
+function getDirname(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const normalized = normalizePath(path, isWin);
+  const lastSepIndex = normalized.lastIndexOf(separator);
+  if (lastSepIndex === -1) return ".";
+  if (lastSepIndex === 0) return separator;
+  return normalized.slice(0, lastSepIndex);
+}
+function getBasename(path, ext, isWin) {
+  if (path.length === 0) return "";
+  const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    return "";
+  }
+  return path.slice(lastDotIndex);
+}
+function parsePath(path, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path[0] === "\\" || path[0] === "/") {
+      root = "\\";
+    }
+  } else {
+    if (path[0] === "/") {
+      root = "/";
+    }
+  }
+  const dir = getDirname(path, isWin);
+  const base = getBasename(path, void 0, isWin);
+  const ext = getExtname(path);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function normalize(path) {
+  return normalizePath(path, isWindows);
+}
+function join(...paths) {
+  return joinPaths(paths, isWindows);
+}
+function resolve(...paths) {
+  return resolvePaths(paths, isWindows);
+}
+function isAbsolute(path) {
+  return isWindows ? win32.isAbsolute(path) : posix.isAbsolute(path);
+}
+function relative(from, to) {
+  return relativePath(from, to, isWindows);
+}
+function dirname(path) {
+  return getDirname(path, isWindows);
+}
+function basename(path, ext) {
+  return getBasename(path, ext, isWindows);
+}
+function extname(path) {
+  return getExtname(path);
+}
+function parse(path) {
+  return parsePath(path, isWindows);
+}
+function format(pathObject) {
+  return formatPath(pathObject, isWindows);
+}
+function toNamespacedPath(path) {
+  if (!isWindows || path.length === 0) return path;
+  const resolved = resolve(path);
+  if (resolved.length >= 3) {
+    if (resolved[0] === "\\") {
+      if (resolved[1] === "\\" && resolved[2] !== "?") {
+        return "\\\\?\\UNC\\" + resolved.slice(2);
+      }
+    } else if (resolved[1] === ":" && resolved[2] === "\\") {
+      return "\\\\?\\" + resolved;
+    }
+  }
+  return path;
+}
+function getRuntime2() {
+  return runtime;
+}
+var isWindows, sep, delimiter, posix, win32, path_default;
+var init_path = __esm({
+  "src/path.ts"() {
+    "use strict";
+    init_runtime();
+    isWindows = (() => {
+      if (isNode) {
+        return process.platform === "win32";
+      } else if (isDeno) {
+        return Deno.build.os === "windows";
+      }
+      return typeof process !== "undefined" && process.platform === "win32";
+    })();
+    sep = isWindows ? "\\" : "/";
+    delimiter = isWindows ? ";" : ":";
+    posix = createPathOps(false);
+    win32 = createPathOps(true);
+    path_default = {
+      sep,
+      delimiter,
+      normalize,
+      join,
+      resolve,
+      isAbsolute,
+      relative,
+      dirname,
+      basename,
+      extname,
+      parse,
+      format,
+      toNamespacedPath,
+      posix,
+      win32,
+      getRuntime: getRuntime2
+    };
+  }
+});
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  defineConfig: () => defineConfig,
+  loadConfig: () => loadConfig,
+  loadEnv: () => loadEnv,
+  mergeConfig: () => mergeConfig
+});
+module.exports = __toCommonJS(config_exports);
+init_fs();
+init_path();
+function readFileAsString(filePath) {
+  const contentBuffer = readFileSync(filePath, "utf-8");
+  return typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString("utf-8");
+}
+function removeQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+async function importConfigModule(configPath) {
+  const { pathToFileURL } = await import("url");
+  const configModule = await import(pathToFileURL(configPath).href);
+  return configModule.default || configModule;
+}
+async function safeCleanup(filePath) {
+  try {
+    const { unlinkSync: unlinkSync2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    unlinkSync2(filePath);
+  } catch {
+  }
+}
+function defineConfig(config) {
+  return config;
+}
+var CONFIG_FILES = [
+  "elit.config.ts",
+  "elit.config.js",
+  "elit.config.mjs",
+  "elit.config.cjs",
+  "elit.config.json"
+];
+function loadEnv(mode = "development", cwd = process.cwd()) {
+  const env = { MODE: mode };
+  const envFiles = [
+    `.env.${mode}.local`,
+    `.env.${mode}`,
+    `.env.local`,
+    `.env`
+  ];
+  for (const file of envFiles) {
+    const filePath = resolve(cwd, file);
+    if (existsSync(filePath)) {
+      const content = readFileAsString(filePath);
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+        if (match) {
+          const [, key, value] = match;
+          const cleanValue = removeQuotes(value);
+          if (!(key in env)) {
+            env[key] = cleanValue;
+          }
+        }
+      }
+    }
+  }
+  return env;
+}
+async function loadConfig(cwd = process.cwd()) {
+  for (const configFile of CONFIG_FILES) {
+    const configPath = resolve(cwd, configFile);
+    if (existsSync(configPath)) {
+      try {
+        return await loadConfigFile(configPath);
+      } catch (error) {
+        console.error(`Error loading config file: ${configFile}`);
+        console.error(error);
+        throw error;
+      }
+    }
+  }
+  return null;
+}
+async function loadConfigFile(configPath) {
+  const ext = configPath.split(".").pop();
+  if (ext === "json") {
+    const content = readFileAsString(configPath);
+    return JSON.parse(content);
+  } else if (ext === "ts") {
+    try {
+      const { build } = await import("esbuild");
+      const { join: join2, dirname: dirname2 } = await Promise.resolve().then(() => (init_path(), path_exports));
+      const configDir = dirname2(configPath);
+      const tempFile = join2(configDir, `.elit-config-${Date.now()}.mjs`);
+      const externalAllPlugin = {
+        name: "external-all",
+        setup(build2) {
+          build2.onResolve({ filter: /.*/ }, (args) => {
+            if (args.path.startsWith("./") || args.path.startsWith("../")) {
+              return void 0;
+            }
+            if (args.path.includes("node_modules") || args.resolveDir?.includes("node_modules")) {
+              return { path: args.path, external: true };
+            }
+            const knownPackages = ["esbuild", "elit", "fs", "path", "os", "vm", "crypto", "http", "https", "url", "bun"];
+            if (knownPackages.some((pkg) => args.path === pkg || args.path.startsWith(pkg + "/"))) {
+              return { path: args.path, external: true };
+            }
+            if (args.resolveDir?.includes("elit/dist") || args.path.includes("elit/dist")) {
+              return { path: args.path, external: true };
+            }
+            return void 0;
+          });
+        }
+      };
+      await build({
+        entryPoints: [configPath],
+        bundle: true,
+        format: "esm",
+        platform: "node",
+        outfile: tempFile,
+        write: true,
+        target: "es2020",
+        plugins: [externalAllPlugin],
+        // External Node.js built-ins and runtime-specific packages
+        external: [
+          "node:*",
+          "fs",
+          "path",
+          "os",
+          "vm",
+          "crypto",
+          "http",
+          "https",
+          "bun",
+          "bun:*",
+          "deno",
+          "deno:*"
+        ],
+        // Use the config directory as the working directory for resolution
+        absWorkingDir: configDir
+      });
+      const config = await importConfigModule(tempFile);
+      await safeCleanup(tempFile);
+      return config;
+    } catch (error) {
+      console.error("Failed to load TypeScript config file.");
+      console.error("You can use a .js, .mjs, or .json config file instead.");
+      throw error;
+    }
+  } else {
+    return await importConfigModule(configPath);
+  }
+}
+function mergeConfig(config, cliArgs) {
+  if (!config) {
+    return cliArgs;
+  }
+  return {
+    ...config,
+    ...Object.fromEntries(
+      Object.entries(cliArgs).filter(([_, v]) => v !== void 0)
+    )
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  loadConfig,
+  loadEnv,
+  mergeConfig
+});