@storm-software/config-tools 1.136.3 → 1.137.0

package/dist/chunk-JBD6MOCX.mjs

@@ -0,0 +1,1733 @@
+import {
+  basename,
+  defu,
+  dirname,
+  extname,
+  fileURLToPath,
+  findWorkspaceDir,
+  join,
+  readPackageJSON,
+  resolve
+} from "./chunk-E25ESST2.mjs";
+import {
+  writeSystem
+} from "./chunk-LL5L564L.mjs";
+import {
+  findWorkspaceRoot
+} from "./chunk-BKXOCTTA.mjs";
+import {
+  joinPaths
+} from "./chunk-IXG2QO76.mjs";
+import {
+  __commonJS,
+  __name,
+  __require,
+  __toESM,
+  init_esm_shims
+} from "./chunk-RZYA76H7.mjs";
+
+// ../../node_modules/.pnpm/dotenv@16.4.7/node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "../../node_modules/.pnpm/dotenv@16.4.7/node_modules/dotenv/package.json"(exports, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "16.4.7",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/dotenv@16.4.7/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv@16.4.7/node_modules/dotenv/lib/main.js"(exports, module) {
+    init_esm_shims();
+    var fs = __require("fs");
+    var path = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse3(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(parse3, "parse");
+    function _parseVault(options) {
+      const vaultPath = _vaultPath(options);
+      const result = DotenvModule.configDotenv({
+        path: vaultPath
+      });
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    __name(_parseVault, "_parseVault");
+    function _log(message) {
+      console.log(`[dotenv@${version}][INFO] ${message}`);
+    }
+    __name(_log, "_log");
+    function _warn(message) {
+      console.log(`[dotenv@${version}][WARN] ${message}`);
+    }
+    __name(_warn, "_warn");
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    __name(_debug, "_debug");
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    __name(_dotenvKey, "_dotenvKey");
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return {
+        ciphertext,
+        key
+      };
+    }
+    __name(_instructions, "_instructions");
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    __name(_vaultPath, "_vaultPath");
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    __name(_resolveHome, "_resolveHome");
+    function _configVault(options) {
+      _log("Loading env from encrypted .env.vault");
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return {
+        parsed
+      };
+    }
+    __name(_configVault, "_configVault");
+    function configDotenv(options) {
+      const dotenvPath = path.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      const debug = Boolean(options && options.debug);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [
+        dotenvPath
+      ];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [
+            _resolveHome(options.path)
+          ];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path2 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path2, {
+            encoding
+          }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path2} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsedAll, options);
+      if (lastError) {
+        return {
+          parsed: parsedAll,
+          error: lastError
+        };
+      } else {
+        return {
+          parsed: parsedAll
+        };
+      }
+    }
+    __name(configDotenv, "configDotenv");
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    __name(config, "config");
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    __name(decrypt, "decrypt");
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+        }
+      }
+    }
+    __name(populate, "populate");
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse: parse3,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// src/config-file/get-config-file.ts
+init_esm_shims();
+
+// ../../node_modules/.pnpm/c12@2.0.1/node_modules/c12/dist/index.mjs
+init_esm_shims();
+
+// ../../node_modules/.pnpm/c12@2.0.1/node_modules/c12/dist/shared/c12.B4fc1S0C.mjs
+init_esm_shims();
+import { existsSync as existsSync2, promises } from "node:fs";
+import { rm, readFile } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { createJiti } from "jiti";
+
+// ../../node_modules/.pnpm/rc9@2.1.2/node_modules/rc9/dist/index.mjs
+init_esm_shims();
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { homedir } from "node:os";
+
+// ../../node_modules/.pnpm/destr@2.0.3/node_modules/destr/dist/index.mjs
+init_esm_shims();
+var suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+var JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+    warnKeyDropped(key);
+    return;
+  }
+  return value;
+}
+__name(jsonParseTransform, "jsonParseTransform");
+function warnKeyDropped(key) {
+  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+__name(warnKeyDropped, "warnKeyDropped");
+function destr(value, options = {}) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const _value = value.trim();
+  if (
+    // eslint-disable-next-line unicorn/prefer-at
+    value[0] === '"' && value.endsWith('"') && !value.includes("\\")
+  ) {
+    return _value.slice(1, -1);
+  }
+  if (_value.length <= 9) {
+    const _lval = _value.toLowerCase();
+    if (_lval === "true") {
+      return true;
+    }
+    if (_lval === "false") {
+      return false;
+    }
+    if (_lval === "undefined") {
+      return void 0;
+    }
+    if (_lval === "null") {
+      return null;
+    }
+    if (_lval === "nan") {
+      return Number.NaN;
+    }
+    if (_lval === "infinity") {
+      return Number.POSITIVE_INFINITY;
+    }
+    if (_lval === "-infinity") {
+      return Number.NEGATIVE_INFINITY;
+    }
+  }
+  if (!JsonSigRx.test(value)) {
+    if (options.strict) {
+      throw new SyntaxError("[destr] Invalid JSON");
+    }
+    return value;
+  }
+  try {
+    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+      if (options.strict) {
+        throw new Error("[destr] Possible prototype pollution");
+      }
+      return JSON.parse(value, jsonParseTransform);
+    }
+    return JSON.parse(value);
+  } catch (error) {
+    if (options.strict) {
+      throw error;
+    }
+    return value;
+  }
+}
+__name(destr, "destr");
+
+// ../../node_modules/.pnpm/rc9@2.1.2/node_modules/rc9/dist/index.mjs
+function isBuffer(obj) {
+  return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+}
+__name(isBuffer, "isBuffer");
+function keyIdentity(key) {
+  return key;
+}
+__name(keyIdentity, "keyIdentity");
+function flatten(target, opts) {
+  opts = opts || {};
+  const delimiter = opts.delimiter || ".";
+  const maxDepth = opts.maxDepth;
+  const transformKey = opts.transformKey || keyIdentity;
+  const output = {};
+  function step(object, prev, currentDepth) {
+    currentDepth = currentDepth || 1;
+    Object.keys(object).forEach(function(key) {
+      const value = object[key];
+      const isarray = opts.safe && Array.isArray(value);
+      const type = Object.prototype.toString.call(value);
+      const isbuffer = isBuffer(value);
+      const isobject = type === "[object Object]" || type === "[object Array]";
+      const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+      if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) {
+        return step(value, newKey, currentDepth + 1);
+      }
+      output[newKey] = value;
+    });
+  }
+  __name(step, "step");
+  step(target);
+  return output;
+}
+__name(flatten, "flatten");
+function unflatten(target, opts) {
+  opts = opts || {};
+  const delimiter = opts.delimiter || ".";
+  const overwrite = opts.overwrite || false;
+  const transformKey = opts.transformKey || keyIdentity;
+  const result = {};
+  const isbuffer = isBuffer(target);
+  if (isbuffer || Object.prototype.toString.call(target) !== "[object Object]") {
+    return target;
+  }
+  function getkey(key) {
+    const parsedKey = Number(key);
+    return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+  }
+  __name(getkey, "getkey");
+  function addKeys(keyPrefix, recipient, target2) {
+    return Object.keys(target2).reduce(function(result2, key) {
+      result2[keyPrefix + delimiter + key] = target2[key];
+      return result2;
+    }, recipient);
+  }
+  __name(addKeys, "addKeys");
+  function isEmpty(val) {
+    const type = Object.prototype.toString.call(val);
+    const isArray = type === "[object Array]";
+    const isObject = type === "[object Object]";
+    if (!val) {
+      return true;
+    } else if (isArray) {
+      return !val.length;
+    } else if (isObject) {
+      return !Object.keys(val).length;
+    }
+  }
+  __name(isEmpty, "isEmpty");
+  target = Object.keys(target).reduce(function(result2, key) {
+    const type = Object.prototype.toString.call(target[key]);
+    const isObject = type === "[object Object]" || type === "[object Array]";
+    if (!isObject || isEmpty(target[key])) {
+      result2[key] = target[key];
+      return result2;
+    } else {
+      return addKeys(
+        key,
+        result2,
+        flatten(target[key], opts)
+      );
+    }
+  }, {});
+  Object.keys(target).forEach(function(key) {
+    const split = key.split(delimiter).map(transformKey);
+    let key1 = getkey(split.shift());
+    let key2 = getkey(split[0]);
+    let recipient = result;
+    while (key2 !== void 0) {
+      if (key1 === "__proto__") {
+        return;
+      }
+      const type = Object.prototype.toString.call(recipient[key1]);
+      const isobject = type === "[object Object]" || type === "[object Array]";
+      if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") {
+        return;
+      }
+      if (overwrite && !isobject || !overwrite && recipient[key1] == null) {
+        recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+      }
+      recipient = recipient[key1];
+      if (split.length > 0) {
+        key1 = getkey(split.shift());
+        key2 = getkey(split[0]);
+      }
+    }
+    recipient[key1] = unflatten(target[key], opts);
+  });
+  return result;
+}
+__name(unflatten, "unflatten");
+var RE_KEY_VAL = /^\s*([^\s=]+)\s*=\s*(.*)?\s*$/;
+var RE_LINES = /\n|\r|\r\n/;
+var defaults = {
+  name: ".conf",
+  dir: process.cwd(),
+  flat: false
+};
+function withDefaults(options) {
+  if (typeof options === "string") {
+    options = { name: options };
+  }
+  return { ...defaults, ...options };
+}
+__name(withDefaults, "withDefaults");
+function parse(contents, options = {}) {
+  const config = {};
+  const lines = contents.split(RE_LINES);
+  for (const line of lines) {
+    const match = line.match(RE_KEY_VAL);
+    if (!match) {
+      continue;
+    }
+    const key = match[1];
+    if (!key || key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = destr(
+      (match[2] || "").trim()
+      /* val */
+    );
+    if (key.endsWith("[]")) {
+      const nkey = key.slice(0, Math.max(0, key.length - 2));
+      config[nkey] = (config[nkey] || []).concat(value);
+      continue;
+    }
+    config[key] = value;
+  }
+  return options.flat ? config : unflatten(config, { overwrite: true });
+}
+__name(parse, "parse");
+function parseFile(path, options) {
+  if (!existsSync(path)) {
+    return {};
+  }
+  return parse(readFileSync(path, "utf8"), options);
+}
+__name(parseFile, "parseFile");
+function read(options) {
+  options = withDefaults(options);
+  return parseFile(resolve2(options.dir, options.name), options);
+}
+__name(read, "read");
+function readUser(options) {
+  options = withDefaults(options);
+  options.dir = process.env.XDG_CONFIG_HOME || homedir();
+  return read(options);
+}
+__name(readUser, "readUser");
+
+// ../../node_modules/.pnpm/ohash@1.1.4/node_modules/ohash/dist/index.mjs
+init_esm_shims();
+var defaults2 = Object.freeze({
+  ignoreUnknown: false,
+  respectType: false,
+  respectFunctionNames: false,
+  respectFunctionProperties: false,
+  unorderedObjects: true,
+  unorderedArrays: false,
+  unorderedSets: false,
+  excludeKeys: void 0,
+  excludeValues: void 0,
+  replacer: void 0
+});
+function objectHash(object, options) {
+  if (options) {
+    options = { ...defaults2, ...options };
+  } else {
+    options = defaults2;
+  }
+  const hasher = createHasher(options);
+  hasher.dispatch(object);
+  return hasher.toString();
+}
+__name(objectHash, "objectHash");
+var defaultPrototypesKeys = Object.freeze([
+  "prototype",
+  "__proto__",
+  "constructor"
+]);
+function createHasher(options) {
+  let buff = "";
+  let context = /* @__PURE__ */ new Map();
+  const write = /* @__PURE__ */ __name((str) => {
+    buff += str;
+  }, "write");
+  return {
+    toString() {
+      return buff;
+    },
+    getContext() {
+      return context;
+    },
+    dispatch(value) {
+      if (options.replacer) {
+        value = options.replacer(value);
+      }
+      const type = value === null ? "null" : typeof value;
+      return this[type](value);
+    },
+    object(object) {
+      if (object && typeof object.toJSON === "function") {
+        return this.object(object.toJSON());
+      }
+      const objString = Object.prototype.toString.call(object);
+      let objType = "";
+      const objectLength = objString.length;
+      if (objectLength < 10) {
+        objType = "unknown:[" + objString + "]";
+      } else {
+        objType = objString.slice(8, objectLength - 1);
+      }
+      objType = objType.toLowerCase();
+      let objectNumber = null;
+      if ((objectNumber = context.get(object)) === void 0) {
+        context.set(object, context.size);
+      } else {
+        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+        write("buffer:");
+        return write(object.toString("utf8"));
+      }
+      if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+        if (this[objType]) {
+          this[objType](object);
+        } else if (!options.ignoreUnknown) {
+          this.unkown(object, objType);
+        }
+      } else {
+        let keys = Object.keys(object);
+        if (options.unorderedObjects) {
+          keys = keys.sort();
+        }
+        let extraKeys = [];
+        if (options.respectType !== false && !isNativeFunction(object)) {
+          extraKeys = defaultPrototypesKeys;
+        }
+        if (options.excludeKeys) {
+          keys = keys.filter((key) => {
+            return !options.excludeKeys(key);
+          });
+          extraKeys = extraKeys.filter((key) => {
+            return !options.excludeKeys(key);
+          });
+        }
+        write("object:" + (keys.length + extraKeys.length) + ":");
+        const dispatchForKey = /* @__PURE__ */ __name((key) => {
+          this.dispatch(key);
+          write(":");
+          if (!options.excludeValues) {
+            this.dispatch(object[key]);
+          }
+          write(",");
+        }, "dispatchForKey");
+        for (const key of keys) {
+          dispatchForKey(key);
+        }
+        for (const key of extraKeys) {
+          dispatchForKey(key);
+        }
+      }
+    },
+    array(arr, unordered) {
+      unordered = unordered === void 0 ? options.unorderedArrays !== false : unordered;
+      write("array:" + arr.length + ":");
+      if (!unordered || arr.length <= 1) {
+        for (const entry of arr) {
+          this.dispatch(entry);
+        }
+        return;
+      }
+      const contextAdditions = /* @__PURE__ */ new Map();
+      const entries = arr.map((entry) => {
+        const hasher = createHasher(options);
+        hasher.dispatch(entry);
+        for (const [key, value] of hasher.getContext()) {
+          contextAdditions.set(key, value);
+        }
+        return hasher.toString();
+      });
+      context = contextAdditions;
+      entries.sort();
+      return this.array(entries, false);
+    },
+    date(date) {
+      return write("date:" + date.toJSON());
+    },
+    symbol(sym) {
+      return write("symbol:" + sym.toString());
+    },
+    unkown(value, type) {
+      write(type);
+      if (!value) {
+        return;
+      }
+      write(":");
+      if (value && typeof value.entries === "function") {
+        return this.array(
+          Array.from(value.entries()),
+          true
+          /* ordered */
+        );
+      }
+    },
+    error(err) {
+      return write("error:" + err.toString());
+    },
+    boolean(bool) {
+      return write("bool:" + bool);
+    },
+    string(string) {
+      write("string:" + string.length + ":");
+      write(string);
+    },
+    function(fn) {
+      write("fn:");
+      if (isNativeFunction(fn)) {
+        this.dispatch("[native]");
+      } else {
+        this.dispatch(fn.toString());
+      }
+      if (options.respectFunctionNames !== false) {
+        this.dispatch("function-name:" + String(fn.name));
+      }
+      if (options.respectFunctionProperties) {
+        this.object(fn);
+      }
+    },
+    number(number) {
+      return write("number:" + number);
+    },
+    xml(xml) {
+      return write("xml:" + xml.toString());
+    },
+    null() {
+      return write("Null");
+    },
+    undefined() {
+      return write("Undefined");
+    },
+    regexp(regex) {
+      return write("regex:" + regex.toString());
+    },
+    uint8array(arr) {
+      write("uint8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    uint8clampedarray(arr) {
+      write("uint8clampedarray:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    int8array(arr) {
+      write("int8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    uint16array(arr) {
+      write("uint16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    int16array(arr) {
+      write("int16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    uint32array(arr) {
+      write("uint32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    int32array(arr) {
+      write("int32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    float32array(arr) {
+      write("float32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    float64array(arr) {
+      write("float64array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    arraybuffer(arr) {
+      write("arraybuffer:");
+      return this.dispatch(new Uint8Array(arr));
+    },
+    url(url) {
+      return write("url:" + url.toString());
+    },
+    map(map) {
+      write("map:");
+      const arr = [...map];
+      return this.array(arr, options.unorderedSets !== false);
+    },
+    set(set) {
+      write("set:");
+      const arr = [...set];
+      return this.array(arr, options.unorderedSets !== false);
+    },
+    file(file) {
+      write("file:");
+      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+    },
+    blob() {
+      if (options.ignoreUnknown) {
+        return write("[blob]");
+      }
+      throw new Error(
+        'Hashing Blob objects is currently not supported\nUse "options.replacer" or "options.ignoreUnknown"\n'
+      );
+    },
+    domwindow() {
+      return write("domwindow");
+    },
+    bigint(number) {
+      return write("bigint:" + number.toString());
+    },
+    /* Node.js standard native objects */
+    process() {
+      return write("process");
+    },
+    timer() {
+      return write("timer");
+    },
+    pipe() {
+      return write("pipe");
+    },
+    tcp() {
+      return write("tcp");
+    },
+    udp() {
+      return write("udp");
+    },
+    tty() {
+      return write("tty");
+    },
+    statwatcher() {
+      return write("statwatcher");
+    },
+    securecontext() {
+      return write("securecontext");
+    },
+    connection() {
+      return write("connection");
+    },
+    zlib() {
+      return write("zlib");
+    },
+    context() {
+      return write("context");
+    },
+    nodescript() {
+      return write("nodescript");
+    },
+    httpparser() {
+      return write("httpparser");
+    },
+    dataview() {
+      return write("dataview");
+    },
+    signal() {
+      return write("signal");
+    },
+    fsevent() {
+      return write("fsevent");
+    },
+    tlswrap() {
+      return write("tlswrap");
+    }
+  };
+}
+__name(createHasher, "createHasher");
+var nativeFunc = "[native code] }";
+var nativeFuncLength = nativeFunc.length;
+function isNativeFunction(f) {
+  if (typeof f !== "function") {
+    return false;
+  }
+  return Function.prototype.toString.call(f).slice(-nativeFuncLength) === nativeFunc;
+}
+__name(isNativeFunction, "isNativeFunction");
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, "__defNormalProp$1");
+var __publicField$1 = /* @__PURE__ */ __name((obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+}, "__publicField$1");
+var WordArray = class _WordArray {
+  static {
+    __name(this, "WordArray");
+  }
+  constructor(words, sigBytes) {
+    __publicField$1(this, "words");
+    __publicField$1(this, "sigBytes");
+    words = this.words = words || [];
+    this.sigBytes = sigBytes === void 0 ? words.length * 4 : sigBytes;
+  }
+  toString(encoder) {
+    return (encoder || Hex).stringify(this);
+  }
+  concat(wordArray) {
+    this.clamp();
+    if (this.sigBytes % 4) {
+      for (let i = 0; i < wordArray.sigBytes; i++) {
+        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;
+      }
+    } else {
+      for (let j = 0; j < wordArray.sigBytes; j += 4) {
+        this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];
+      }
+    }
+    this.sigBytes += wordArray.sigBytes;
+    return this;
+  }
+  clamp() {
+    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;
+    this.words.length = Math.ceil(this.sigBytes / 4);
+  }
+  clone() {
+    return new _WordArray([...this.words]);
+  }
+};
+var Hex = {
+  stringify(wordArray) {
+    const hexChars = [];
+    for (let i = 0; i < wordArray.sigBytes; i++) {
+      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      hexChars.push((bite >>> 4).toString(16), (bite & 15).toString(16));
+    }
+    return hexChars.join("");
+  }
+};
+var Base64 = {
+  stringify(wordArray) {
+    const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const base64Chars = [];
+    for (let i = 0; i < wordArray.sigBytes; i += 3) {
+      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+      const triplet = byte1 << 16 | byte2 << 8 | byte3;
+      for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {
+        base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));
+      }
+    }
+    return base64Chars.join("");
+  }
+};
+var Latin1 = {
+  parse(latin1Str) {
+    const latin1StrLength = latin1Str.length;
+    const words = [];
+    for (let i = 0; i < latin1StrLength; i++) {
+      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+    }
+    return new WordArray(words, latin1StrLength);
+  }
+};
+var Utf8 = {
+  parse(utf8Str) {
+    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+  }
+};
+var BufferedBlockAlgorithm = class {
+  static {
+    __name(this, "BufferedBlockAlgorithm");
+  }
+  constructor() {
+    __publicField$1(this, "_data", new WordArray());
+    __publicField$1(this, "_nDataBytes", 0);
+    __publicField$1(this, "_minBufferSize", 0);
+    __publicField$1(this, "blockSize", 512 / 32);
+  }
+  reset() {
+    this._data = new WordArray();
+    this._nDataBytes = 0;
+  }
+  _append(data) {
+    if (typeof data === "string") {
+      data = Utf8.parse(data);
+    }
+    this._data.concat(data);
+    this._nDataBytes += data.sigBytes;
+  }
+  _doProcessBlock(_dataWords, _offset) {
+  }
+  _process(doFlush) {
+    let processedWords;
+    let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);
+    if (doFlush) {
+      nBlocksReady = Math.ceil(nBlocksReady);
+    } else {
+      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+    }
+    const nWordsReady = nBlocksReady * this.blockSize;
+    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);
+    if (nWordsReady) {
+      for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {
+        this._doProcessBlock(this._data.words, offset);
+      }
+      processedWords = this._data.words.splice(0, nWordsReady);
+      this._data.sigBytes -= nBytesReady;
+    }
+    return new WordArray(processedWords, nBytesReady);
+  }
+};
+var Hasher = class extends BufferedBlockAlgorithm {
+  static {
+    __name(this, "Hasher");
+  }
+  update(messageUpdate) {
+    this._append(messageUpdate);
+    this._process();
+    return this;
+  }
+  finalize(messageUpdate) {
+    if (messageUpdate) {
+      this._append(messageUpdate);
+    }
+  }
+};
+var __defProp = Object.defineProperty;
+var __defNormalProp = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, "__defNormalProp");
+var __publicField = /* @__PURE__ */ __name((obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+}, "__publicField");
+var H = [
+  1779033703,
+  -1150833019,
+  1013904242,
+  -1521486534,
+  1359893119,
+  -1694144372,
+  528734635,
+  1541459225
+];
+var K = [
+  1116352408,
+  1899447441,
+  -1245643825,
+  -373957723,
+  961987163,
+  1508970993,
+  -1841331548,
+  -1424204075,
+  -670586216,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  -2132889090,
+  -1680079193,
+  -1046744716,
+  -459576895,
+  -272742522,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  -1740746414,
+  -1473132947,
+  -1341970488,
+  -1084653625,
+  -958395405,
+  -710438585,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  -2117940946,
+  -1838011259,
+  -1564481375,
+  -1474664885,
+  -1035236496,
+  -949202525,
+  -778901479,
+  -694614492,
+  -200395387,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  -2067236844,
+  -1933114872,
+  -1866530822,
+  -1538233109,
+  -1090935817,
+  -965641998
+];
+var W = [];
+var SHA256 = class extends Hasher {
+  static {
+    __name(this, "SHA256");
+  }
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_hash", new WordArray([...H]));
+  }
+  /**
+   * Resets the internal state of the hash object to initial values.
+   */
+  reset() {
+    super.reset();
+    this._hash = new WordArray([...H]);
+  }
+  _doProcessBlock(M, offset) {
+    const H2 = this._hash.words;
+    let a = H2[0];
+    let b = H2[1];
+    let c = H2[2];
+    let d = H2[3];
+    let e = H2[4];
+    let f = H2[5];
+    let g = H2[6];
+    let h = H2[7];
+    for (let i = 0; i < 64; i++) {
+      if (i < 16) {
+        W[i] = M[offset + i] | 0;
+      } else {
+        const gamma0x = W[i - 15];
+        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
+        const gamma1x = W[i - 2];
+        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
+        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
+      }
+      const ch = e & f ^ ~e & g;
+      const maj = a & b ^ a & c ^ b & c;
+      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
+      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
+      const t1 = h + sigma1 + ch + K[i] + W[i];
+      const t2 = sigma0 + maj;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    H2[0] = H2[0] + a | 0;
+    H2[1] = H2[1] + b | 0;
+    H2[2] = H2[2] + c | 0;
+    H2[3] = H2[3] + d | 0;
+    H2[4] = H2[4] + e | 0;
+    H2[5] = H2[5] + f | 0;
+    H2[6] = H2[6] + g | 0;
+    H2[7] = H2[7] + h | 0;
+  }
+  /**
+   * Finishes the hash calculation and returns the hash as a WordArray.
+   *
+   * @param {string} messageUpdate - Additional message content to include in the hash.
+   * @returns {WordArray} The finalised hash as a WordArray.
+   */
+  finalize(messageUpdate) {
+    super.finalize(messageUpdate);
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = this._data.sigBytes * 8;
+    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(
+      nBitsTotal / 4294967296
+    );
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.sigBytes = this._data.words.length * 4;
+    this._process();
+    return this._hash;
+  }
+};
+function sha256base64(message) {
+  return new SHA256().finalize(message).toString(Base64);
+}
+__name(sha256base64, "sha256base64");
+function hash(object, options = {}) {
+  const hashed = typeof object === "string" ? object : objectHash(object, options);
+  return sha256base64(hashed).slice(0, 10);
+}
+__name(hash, "hash");
+
+// ../../node_modules/.pnpm/c12@2.0.1/node_modules/c12/dist/shared/c12.B4fc1S0C.mjs
+var dotenv = __toESM(require_main(), 1);
+async function setupDotenv(options) {
+  const targetEnvironment = options.env ?? process.env;
+  const environment = await loadDotenv({
+    cwd: options.cwd,
+    fileName: options.fileName ?? ".env",
+    env: targetEnvironment,
+    interpolate: options.interpolate ?? true
+  });
+  for (const key in environment) {
+    if (!key.startsWith("_") && targetEnvironment[key] === void 0) {
+      targetEnvironment[key] = environment[key];
+    }
+  }
+  return environment;
+}
+__name(setupDotenv, "setupDotenv");
+async function loadDotenv(options) {
+  const environment = /* @__PURE__ */ Object.create(null);
+  const dotenvFile = resolve(options.cwd, options.fileName);
+  if (existsSync2(dotenvFile)) {
+    const parsed = dotenv.parse(await promises.readFile(dotenvFile, "utf8"));
+    Object.assign(environment, parsed);
+  }
+  if (!options.env?._applied) {
+    Object.assign(environment, options.env);
+    environment._applied = true;
+  }
+  if (options.interpolate) {
+    interpolate(environment);
+  }
+  return environment;
+}
+__name(loadDotenv, "loadDotenv");
+function interpolate(target, source = {}, parse3 = (v) => v) {
+  function getValue(key) {
+    return source[key] === void 0 ? target[key] : source[key];
+  }
+  __name(getValue, "getValue");
+  function interpolate2(value, parents = []) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const matches = value.match(/(.?\${?(?:[\w:]+)?}?)/g) || [];
+    return parse3(
+      // eslint-disable-next-line unicorn/no-array-reduce
+      matches.reduce((newValue, match) => {
+        const parts = /(.?)\${?([\w:]+)?}?/g.exec(match) || [];
+        const prefix = parts[1];
+        let value2, replacePart;
+        if (prefix === "\\") {
+          replacePart = parts[0] || "";
+          value2 = replacePart.replace(String.raw`\$`, "$");
+        } else {
+          const key = parts[2];
+          replacePart = (parts[0] || "").slice(prefix.length);
+          if (parents.includes(key)) {
+            console.warn(
+              `Please avoid recursive environment variables ( loop: ${parents.join(
+                " > "
+              )} > ${key} )`
+            );
+            return "";
+          }
+          value2 = getValue(key);
+          value2 = interpolate2(value2, [...parents, key]);
+        }
+        return value2 === void 0 ? newValue : newValue.replace(replacePart, value2);
+      }, value)
+    );
+  }
+  __name(interpolate2, "interpolate2");
+  for (const key in target) {
+    target[key] = interpolate2(getValue(key));
+  }
+}
+__name(interpolate, "interpolate");
+var _normalize = /* @__PURE__ */ __name((p) => p?.replace(/\\/g, "/"), "_normalize");
+var ASYNC_LOADERS = {
+  ".yaml": /* @__PURE__ */ __name(() => import("./yaml-KYTKYGLP.mjs").then((r) => r.parseYAML), ".yaml"),
+  ".yml": /* @__PURE__ */ __name(() => import("./yaml-KYTKYGLP.mjs").then((r) => r.parseYAML), ".yml"),
+  ".jsonc": /* @__PURE__ */ __name(() => import("./jsonc-QMXWMKWV.mjs").then((r) => r.parseJSONC), ".jsonc"),
+  ".json5": /* @__PURE__ */ __name(() => import("./json5-PFHFTE3S.mjs").then((r) => r.parseJSON5), ".json5"),
+  ".toml": /* @__PURE__ */ __name(() => import("./toml-5DG5WNM7.mjs").then((r) => r.parseTOML), ".toml")
+};
+var SUPPORTED_EXTENSIONS = [
+  // with jiti
+  ".js",
+  ".ts",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".json",
+  // with confbox
+  ".jsonc",
+  ".json5",
+  ".yaml",
+  ".yml",
+  ".toml"
+];
+async function loadConfig(options) {
+  options.cwd = resolve(process.cwd(), options.cwd || ".");
+  options.name = options.name || "config";
+  options.envName = options.envName ?? process.env.NODE_ENV;
+  options.configFile = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`);
+  options.rcFile = options.rcFile ?? `.${options.name}rc`;
+  if (options.extend !== false) {
+    options.extend = {
+      extendKey: "extends",
+      ...options.extend
+    };
+  }
+  const _merger = options.merger || defu;
+  options.jiti = options.jiti || createJiti(join(options.cwd, options.configFile), {
+    interopDefault: true,
+    moduleCache: false,
+    extensions: [...SUPPORTED_EXTENSIONS],
+    ...options.jitiOptions
+  });
+  const r = {
+    config: {},
+    cwd: options.cwd,
+    configFile: resolve(options.cwd, options.configFile),
+    layers: []
+  };
+  const _configs = {
+    overrides: options.overrides,
+    main: void 0,
+    rc: void 0,
+    packageJson: void 0,
+    defaultConfig: options.defaultConfig
+  };
+  if (options.dotenv) {
+    await setupDotenv({
+      cwd: options.cwd,
+      ...options.dotenv === true ? {} : options.dotenv
+    });
+  }
+  const _mainConfig = await resolveConfig(".", options);
+  if (_mainConfig.configFile) {
+    _configs.main = _mainConfig.config;
+    r.configFile = _mainConfig.configFile;
+  }
+  if (options.rcFile) {
+    const rcSources = [];
+    rcSources.push(read({ name: options.rcFile, dir: options.cwd }));
+    if (options.globalRc) {
+      const workspaceDir = await findWorkspaceDir(options.cwd).catch(() => {
+      });
+      if (workspaceDir) {
+        rcSources.push(read({ name: options.rcFile, dir: workspaceDir }));
+      }
+      rcSources.push(readUser({ name: options.rcFile, dir: options.cwd }));
+    }
+    _configs.rc = _merger({}, ...rcSources);
+  }
+  if (options.packageJson) {
+    const keys = (Array.isArray(options.packageJson) ? options.packageJson : [
+      typeof options.packageJson === "string" ? options.packageJson : options.name
+    ]).filter((t) => t && typeof t === "string");
+    const pkgJsonFile = await readPackageJSON(options.cwd).catch(() => {
+    });
+    const values = keys.map((key) => pkgJsonFile?.[key]);
+    _configs.packageJson = _merger({}, ...values);
+  }
+  const configs = {};
+  for (const key in _configs) {
+    const value = _configs[key];
+    configs[key] = await (typeof value === "function" ? value({ configs }) : value);
+  }
+  r.config = _merger(
+    configs.overrides,
+    configs.main,
+    configs.rc,
+    configs.packageJson,
+    configs.defaultConfig
+  );
+  if (options.extend) {
+    await extendConfig(r.config, options);
+    r.layers = r.config._layers;
+    delete r.config._layers;
+    r.config = _merger(r.config, ...r.layers.map((e) => e.config));
+  }
+  const baseLayers = [
+    configs.overrides && {
+      config: configs.overrides,
+      configFile: void 0,
+      cwd: void 0
+    },
+    { config: configs.main, configFile: options.configFile, cwd: options.cwd },
+    configs.rc && { config: configs.rc, configFile: options.rcFile },
+    configs.packageJson && {
+      config: configs.packageJson,
+      configFile: "package.json"
+    }
+  ].filter((l) => l && l.config);
+  r.layers = [...baseLayers, ...r.layers];
+  if (options.defaults) {
+    r.config = _merger(r.config, options.defaults);
+  }
+  if (options.omit$Keys) {
+    for (const key in r.config) {
+      if (key.startsWith("$")) {
+        delete r.config[key];
+      }
+    }
+  }
+  return r;
+}
+__name(loadConfig, "loadConfig");
+async function extendConfig(config, options) {
+  config._layers = config._layers || [];
+  if (!options.extend) {
+    return;
+  }
+  let keys = options.extend.extendKey;
+  if (typeof keys === "string") {
+    keys = [keys];
+  }
+  const extendSources = [];
+  for (const key of keys) {
+    extendSources.push(
+      ...(Array.isArray(config[key]) ? config[key] : [config[key]]).filter(
+        Boolean
+      )
+    );
+    delete config[key];
+  }
+  for (let extendSource of extendSources) {
+    const originalExtendSource = extendSource;
+    let sourceOptions = {};
+    if (extendSource.source) {
+      sourceOptions = extendSource.options || {};
+      extendSource = extendSource.source;
+    }
+    if (Array.isArray(extendSource)) {
+      sourceOptions = extendSource[1] || {};
+      extendSource = extendSource[0];
+    }
+    if (typeof extendSource !== "string") {
+      console.warn(
+        `Cannot extend config from \`${JSON.stringify(
+          originalExtendSource
+        )}\` in ${options.cwd}`
+      );
+      continue;
+    }
+    const _config = await resolveConfig(extendSource, options, sourceOptions);
+    if (!_config.config) {
+      console.warn(
+        `Cannot extend config from \`${extendSource}\` in ${options.cwd}`
+      );
+      continue;
+    }
+    await extendConfig(_config.config, { ...options, cwd: _config.cwd });
+    config._layers.push(_config);
+    if (_config.config._layers) {
+      config._layers.push(..._config.config._layers);
+      delete _config.config._layers;
+    }
+  }
+}
+__name(extendConfig, "extendConfig");
+var GIGET_PREFIXES = [
+  "gh:",
+  "github:",
+  "gitlab:",
+  "bitbucket:",
+  "https://",
+  "http://"
+];
+var NPM_PACKAGE_RE = /^(@[\da-z~-][\d._a-z~-]*\/)?[\da-z~-][\d._a-z~-]*($|\/.*)/;
+async function resolveConfig(source, options, sourceOptions = {}) {
+  if (options.resolve) {
+    const res2 = await options.resolve(source, options);
+    if (res2) {
+      return res2;
+    }
+  }
+  const _merger = options.merger || defu;
+  if (options.giget !== false && GIGET_PREFIXES.some((prefix) => source.startsWith(prefix))) {
+    const { downloadTemplate } = await import("./dist-ESY54GEK.mjs");
+    const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + hash(source);
+    let cloneDir;
+    const localNodeModules = resolve(options.cwd, "node_modules");
+    const parentDir = dirname(options.cwd);
+    if (basename(parentDir) === ".c12") {
+      cloneDir = join(parentDir, cloneName);
+    } else if (existsSync2(localNodeModules)) {
+      cloneDir = join(localNodeModules, ".c12", cloneName);
+    } else {
+      cloneDir = process.env.XDG_CACHE_HOME ? resolve(process.env.XDG_CACHE_HOME, "c12", cloneName) : resolve(homedir2(), ".cache/c12", cloneName);
+    }
+    if (existsSync2(cloneDir) && !sourceOptions.install) {
+      await rm(cloneDir, { recursive: true });
+    }
+    const cloned = await downloadTemplate(source, {
+      dir: cloneDir,
+      install: sourceOptions.install,
+      force: sourceOptions.install,
+      auth: sourceOptions.auth,
+      ...options.giget,
+      ...sourceOptions.giget
+    });
+    source = cloned.dir;
+  }
+  const tryResolve = /* @__PURE__ */ __name((id) => {
+    const resolved = options.jiti.esmResolve(id, { try: true });
+    return resolved ? fileURLToPath(resolved) : void 0;
+  }, "tryResolve");
+  if (NPM_PACKAGE_RE.test(source)) {
+    source = tryResolve(source) || source;
+  }
+  const ext = extname(source);
+  const isDir = !ext || ext === basename(source);
+  const cwd = resolve(options.cwd, isDir ? source : dirname(source));
+  if (isDir) {
+    source = options.configFile;
+  }
+  const res = {
+    config: void 0,
+    configFile: void 0,
+    cwd,
+    source,
+    sourceOptions
+  };
+  res.configFile = tryResolve(resolve(cwd, source)) || tryResolve(resolve(cwd, ".config", source.replace(/\.config$/, ""))) || tryResolve(resolve(cwd, ".config", source)) || source;
+  if (!existsSync2(res.configFile)) {
+    return res;
+  }
+  const configFileExt = extname(res.configFile) || "";
+  if (configFileExt in ASYNC_LOADERS) {
+    const asyncLoader = await ASYNC_LOADERS[configFileExt]();
+    const contents = await readFile(res.configFile, "utf8");
+    res.config = asyncLoader(contents);
+  } else {
+    res.config = await options.jiti.import(res.configFile, {
+      default: true
+    });
+  }
+  if (res.config instanceof Function) {
+    res.config = await res.config();
+  }
+  if (options.envName) {
+    const envConfig = {
+      ...res.config["$" + options.envName],
+      ...res.config.$env?.[options.envName]
+    };
+    if (Object.keys(envConfig).length > 0) {
+      res.config = _merger(envConfig, res.config);
+    }
+  }
+  res.meta = defu(res.sourceOptions.meta, res.config.$meta);
+  delete res.config.$meta;
+  if (res.sourceOptions.overrides) {
+    res.config = _merger(res.sourceOptions.overrides, res.config);
+  }
+  res.configFile = _normalize(res.configFile);
+  res.source = _normalize(res.source);
+  return res;
+}
+__name(resolveConfig, "resolveConfig");
+
+// ../../node_modules/.pnpm/c12@2.0.1/node_modules/c12/dist/index.mjs
+import "jiti";
+var import_dotenv = __toESM(require_main(), 1);
+
+// src/config-file/get-config-file.ts
+var getConfigFileByName = /* @__PURE__ */ __name(async (fileName, filePath, options = {}) => {
+  const workspacePath = filePath || findWorkspaceRoot(filePath);
+  let config = await loadConfig({
+    cwd: workspacePath,
+    packageJson: true,
+    name: fileName,
+    envName: fileName?.toUpperCase(),
+    jitiOptions: {
+      debug: false,
+      fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(process.env.STORM_CACHE_DIR || "node_modules/.cache/storm", "jiti")
+    },
+    ...options
+  });
+  if (!config || Object.keys(config).length === 0) {
+    config = await loadConfig({
+      cwd: workspacePath,
+      packageJson: true,
+      name: fileName,
+      envName: fileName?.toUpperCase(),
+      jitiOptions: {
+        debug: false,
+        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(process.env.STORM_CACHE_DIR || "node_modules/.cache/storm", "jiti")
+      },
+      configFile: fileName,
+      ...options
+    });
+  }
+  return config;
+}, "getConfigFileByName");
+var getConfigFile = /* @__PURE__ */ __name(async (filePath, additionalFileNames = []) => {
+  const workspacePath = filePath ? filePath : findWorkspaceRoot(filePath);
+  const result = await getConfigFileByName("storm", workspacePath);
+  let config = result.config;
+  const configFile = result.configFile;
+  if (config && configFile && Object.keys(config).length > 0) {
+    writeSystem(`Found Storm configuration file "${configFile.includes(`${workspacePath}/`) ? configFile.replace(`${workspacePath}/`, "") : configFile}" at "${workspacePath}"`, {
+      logLevel: "all"
+    });
+  }
+  if (additionalFileNames && additionalFileNames.length > 0) {
+    const results = await Promise.all(additionalFileNames.map((fileName) => getConfigFileByName(fileName, workspacePath)));
+    for (const result2 of results) {
+      if (result2?.config && result2?.configFile && Object.keys(result2.config).length > 0) {
+        writeSystem(`Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`, {
+          logLevel: "all"
+        });
+        config = defu(result2.config ?? {}, config ?? {});
+      }
+    }
+  }
+  if (!config) {
+    return void 0;
+  }
+  config.configFile = configFile;
+  return config;
+}, "getConfigFile");
+
+export {
+  getConfigFileByName,
+  getConfigFile
+};