silgi 0.24.15 → 0.24.17

package/dist/cli/config/resolvers/imports.mjs

@@ -0,0 +1,96 @@
+import escapeRE from 'escape-string-regexp';
+import { resolveModuleExportNames } from 'mlly';
+import { join } from 'pathe';
+
+async function resolveImportsOptions(options) {
+  if (options.imports === false) {
+    return;
+  }
+  options.imports.presets ??= [];
+  options.imports.presets.push(...getSilgiImportsPreset());
+  if (options.preset === "h3") {
+    const h3Exports = await resolveModuleExportNames("h3", {
+      url: import.meta.url
+    });
+    options.imports.presets ??= [];
+    options.imports.presets.push({
+      from: "h3",
+      imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+    });
+  }
+  options.imports.dirs ??= [];
+  options.imports.dirs.push(
+    ...options.scanDirs.map((dir) => join(dir, "utils/**/*"))
+  );
+  if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
+    options.imports.exclude.push(/[/\\]\.git[/\\]/);
+    options.imports.exclude.push(options.build.dir);
+    const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
+    options.imports.exclude.push(
+      scanDirsInNodeModules.length > 0 ? new RegExp(
+        `node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeRE(dir)).join("|")})`
+      ) : /[/\\]node_modules[/\\]/
+    );
+  }
+}
+function getSilgiImportsPreset() {
+  return [
+    // TODO: buraya bizim importlarimiz gelecek.
+    {
+      from: "silgi",
+      imports: [
+        "createShared",
+        "useSilgi",
+        "createService",
+        "createSchema"
+      ]
+    },
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['useRuntimeConfig', 'useAppConfig'],
+    // },
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['defineNitroPlugin', 'nitroPlugin'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/cache',
+    //   imports: [
+    //     'defineCachedFunction',
+    //     'defineCachedEventHandler',
+    //     'cachedFunction',
+    //     'cachedEventHandler',
+    //   ],
+    // },
+    {
+      from: "silgi",
+      imports: ["useSilgiStorage"]
+    }
+    // {
+    //   from: 'nitropack/runtime/internal/renderer',
+    //   imports: ['defineRenderHandler'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/meta',
+    //   imports: ['defineRouteMeta'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/route-rules',
+    //   imports: ['getRouteRules'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/context',
+    //   imports: ['useEvent'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/task',
+    //   imports: ['defineTask', 'runTask'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/error/utils',
+    //   imports: ['defineNitroErrorHandler'],
+    // },
+  ];
+}
+
+export { resolveImportsOptions };

package/dist/cli/config/resolvers/paths.mjs

@@ -0,0 +1,167 @@
+import { existsSync } from 'node:fs';
+import { resolve, join } from 'pathe';
+import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
+import { resolveSilgiPath } from 'silgi/kit';
+import { runtimeDir, pkgDir } from 'silgi/runtime/meta';
+import { SilgiCLIDefaults } from '../defaults.mjs';
+
+async function resolvePathOptions(options) {
+  options.rootDir = resolve(options.rootDir || ".");
+  options.workspaceDir = await findWorkspaceDir(options.rootDir).catch(
+    () => options.rootDir
+  );
+  options.srcDir = resolve(options.srcDir || options.rootDir);
+  for (const key of ["srcDir"]) {
+    options[key] = resolve(options.rootDir, options[key]);
+  }
+  options.build.dir = resolve(options.rootDir, options.build.dir);
+  options.build.typesDir = resolveSilgiPath(
+    options.build.typesDir || SilgiCLIDefaults.build.typesDir,
+    options,
+    options.rootDir
+  );
+  if (options.preset === "npm-package") {
+    const packageJsonPath = resolve(options.rootDir, "package.json");
+    const packageJson = await readPackageJSON(packageJsonPath);
+    if (packageJson.name === void 0) {
+      throw new Error("Package name is undefined");
+    }
+    options.alias ||= {};
+    options.alias[packageJson.name] = join(options.rootDir, "src/module");
+    options.alias[`${packageJson.name}/runtime/`] = join(options.rootDir, "src/runtime");
+    options.alias[`${packageJson.name}/runtime/*`] = join(options.rootDir, "src/runtime/*");
+    options.alias[`${packageJson.name}/types`] = join(options.rootDir, "src/types");
+  }
+  if (options.stub) {
+    options.alias = {
+      ...options.alias,
+      "silgi/runtime": join(runtimeDir),
+      "#internal/silgi": join(runtimeDir),
+      "silgi/runtime/*": join(runtimeDir, "*"),
+      "#internal/silgi/*": join(runtimeDir, "*")
+    };
+  }
+  options.alias = {
+    ...options.alias,
+    "~/": join(options.srcDir, "/"),
+    "@/": join(options.srcDir, "/"),
+    "~~/": join(options.rootDir, "/"),
+    "@@/": join(options.rootDir, "/")
+  };
+  if (options.preset === "npm-package") {
+    options.alias = {
+      ...options.alias
+      // '#silgi/app/': join(options.build.dir, '/'),
+    };
+  }
+  if (options.alias && typeof options.alias === "object") {
+    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+    const paths = options.typescript.tsConfig.compilerOptions.paths;
+    for (const [key, value] of Object.entries(options.alias)) {
+      if (typeof paths === "object") {
+        paths[key] = [value];
+      }
+    }
+  }
+  if (options.typescript.tsConfig.compilerOptions?.paths && typeof options.typescript.tsConfig.compilerOptions.paths === "object") {
+    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+    const paths = options.typescript.tsConfig.compilerOptions.paths;
+    for (const [key, value] of Object.entries(options.alias)) {
+      if (typeof paths === "object") {
+        paths[key] = [value];
+      }
+    }
+  }
+  options.modulesDir = [resolve(options.rootDir, "node_modules")];
+  options.output.dir = resolveSilgiPath(
+    options.output.dir || SilgiCLIDefaults.output.dir,
+    options,
+    options.rootDir
+  );
+  options.output.publicDir = resolveSilgiPath(
+    options.output.publicDir || SilgiCLIDefaults.output.publicDir,
+    options,
+    options.rootDir
+  );
+  options.output.serverDir = resolveSilgiPath(
+    options.output.serverDir || SilgiCLIDefaults.output.serverDir,
+    options,
+    options.rootDir
+  );
+  options.serverDir = resolveSilgiPath(
+    options.serverDir || SilgiCLIDefaults.serverDir,
+    options,
+    options.rootDir
+  );
+  options.clientDir = resolveSilgiPath(
+    options.clientDir || SilgiCLIDefaults.clientDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.serverDir = resolveSilgiPath(
+    options.silgi.serverDir || SilgiCLIDefaults.silgi.serverDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.clientDir = resolveSilgiPath(
+    options.silgi.clientDir || SilgiCLIDefaults.silgi.clientDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.publicDir = resolveSilgiPath(
+    options.silgi.publicDir || SilgiCLIDefaults.silgi.publicDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.utilsDir = resolveSilgiPath(
+    options.silgi.utilsDir || SilgiCLIDefaults.silgi.utilsDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.vfsDir = resolveSilgiPath(
+    options.silgi.vfsDir || SilgiCLIDefaults.silgi.vfsDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.typesDir = resolveSilgiPath(
+    options.silgi.typesDir || SilgiCLIDefaults.silgi.typesDir,
+    options,
+    options.rootDir
+  );
+  options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, ".."));
+  options.nodeModulesDirs = [
+    ...new Set(
+      options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir))
+    )
+  ];
+  options.scanDirs.unshift(options.srcDir);
+  options.scanDirs = options.scanDirs.map(
+    (dir) => resolve(options.srcDir, dir)
+  );
+  options.scanDirs = [...new Set(options.scanDirs)];
+  options.appConfigFiles ??= [];
+  options.appConfigFiles = options.appConfigFiles.map((file) => _tryResolve(resolveSilgiPath(file, options))).filter(Boolean);
+  for (const dir of options.scanDirs) {
+    const configFile = _tryResolve("app.config", dir);
+    if (configFile && !options.appConfigFiles.includes(configFile)) {
+      options.appConfigFiles.push(configFile);
+    }
+  }
+}
+function _tryResolve(path, base = ".", extensions = ["", ".js", ".ts", ".mjs", ".cjs", ".json"]) {
+  path = resolve(base, path);
+  if (existsSync(path)) {
+    return path;
+  }
+  for (const ext of extensions) {
+    const p = path + ext;
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+}
+
+export { resolvePathOptions };

package/dist/cli/config/resolvers/storage.mjs

@@ -0,0 +1,25 @@
+import { resolve } from 'pathe';
+
+async function resolveStorageOptions(options) {
+  const fsMounts = {
+    root: resolve(options.rootDir),
+    src: resolve(options.srcDir),
+    build: resolve(options.build.dir),
+    cache: resolve(options.build.dir, "cache")
+  };
+  for (const p in fsMounts) {
+    options.devStorage[p] = options.devStorage[p] || {
+      driver: "fs",
+      readOnly: p === "root" || p === "src",
+      base: fsMounts[p]
+    };
+  }
+  if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) {
+    options.devStorage.data = {
+      driver: "fs",
+      base: resolve(options.rootDir, ".data/kv")
+    };
+  }
+}
+
+export { resolveStorageOptions };

package/dist/cli/config/resolvers/url.mjs

@@ -0,0 +1,7 @@
+import { withLeadingSlash, withTrailingSlash } from 'ufo';
+
+async function resolveURLOptions(options) {
+  options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
+}
+
+export { resolveURLOptions };

package/dist/cli/config/types.mjs

@@ -0,0 +1,191 @@
+import { promises, lstatSync } from 'node:fs';
+import { defu } from 'defu';
+import { resolve, dirname, join, isAbsolute, relative } from 'pathe';
+import { readPackageJSON } from 'pkg-types';
+import { relativeWithDot, resolveSilgiModule } from 'silgi/kit';
+import { withTrailingSlash } from 'ufo';
+
+function getDirectory(p) {
+  try {
+    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
+  } catch {
+  }
+  return p;
+}
+function renderAttrs(obj) {
+  const attrs = [];
+  for (const key in obj) {
+    attrs.push(renderAttr(key, obj[key]));
+  }
+  return attrs.join(" ");
+}
+function renderAttr(key, value) {
+  return value ? `${key}="${value}"` : "";
+}
+async function silgiGenerateType(silgi) {
+  const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
+  const tsConfigPath = resolve(
+    silgi.options.rootDir,
+    silgi.options.typescript.tsconfigPath
+  );
+  const tsconfigDir = dirname(tsConfigPath);
+  const include = /* @__PURE__ */ new Set([
+    relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi.d.ts")).replace(
+      /^(?=[^.])/,
+      "./"
+    ),
+    join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
+    ...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
+  ]);
+  const exclude = /* @__PURE__ */ new Set([
+    // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
+    relativeWithDot(tsconfigDir, "node_modules"),
+    relativeWithDot(tsconfigDir, "dist")
+  ]);
+  for (const dir of silgi.options.modulesDir) {
+    exclude.add(relativeWithDot(silgi.options.build.dir, dir));
+  }
+  const moduleEntryPaths = [];
+  for (const m of silgi.scanModules) {
+    if (m.entryPath) {
+      moduleEntryPaths.push(getDirectory(m.entryPath));
+    }
+  }
+  const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
+  for (const path of modulePaths) {
+    const relative2 = relativeWithDot(tsconfigDir, path);
+    include.add(join(relative2, "runtime"));
+    exclude.add(join(relative2, "runtime/server"));
+    include.add(join(relative2, "dist/runtime"));
+    exclude.add(join(relative2, "dist/runtime/server"));
+  }
+  const userTsConfig = {
+    compilerOptions: {
+      /* Base options: */
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      skipLibCheck: true,
+      allowImportingTsExtensions: true,
+      /* Target options: */
+      target: "ESNext",
+      allowJs: true,
+      resolveJsonModule: true,
+      moduleDetection: "force",
+      isolatedModules: true,
+      verbatimModuleSyntax: true,
+      /* Strictness */
+      strict: silgi.options.typescript.strict,
+      noUncheckedIndexedAccess: true,
+      noImplicitOverride: true,
+      forceConsistentCasingInFileNames: true,
+      /* If NOT transpiling with TypeScript: */
+      module: "Preserve",
+      customConditions: silgi.options.typescript.customConditions,
+      paths: {
+        // '#silgiImports': [
+        //   relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, 'silgi-imports')),
+        // ],
+        ...silgi.scanModules.reduce((acc, m) => {
+          if (m.entryPath) {
+            acc[m.meta.name] = [relativeWithDot(tsconfigDir, m.entryPath)];
+          }
+          return acc;
+        }, {}),
+        ...silgi.scanModules.reduce((acc, m) => {
+          if (m.entryPath) {
+            const directory = getDirectory(m.entryPath);
+            acc[`${m.meta.name}/*`] = [`${relativeWithDot(tsconfigDir, directory)}/*`];
+          }
+          return acc;
+        }, {})
+      }
+    },
+    include: [...include],
+    exclude: [...exclude]
+  };
+  const npmPackageTsConfig = {
+    compilerOptions: {
+      target: "es2022",
+      lib: ["es2022", "webworker", "dom.iterable"],
+      moduleDetection: "force",
+      /* If NOT transpiling with TypeScript: */
+      module: "preserve",
+      paths: {},
+      resolveJsonModule: true,
+      allowJs: true,
+      /* Strictness */
+      strict: true,
+      noImplicitOverride: true,
+      noEmit: true,
+      allowSyntheticDefaultImports: true,
+      /* Base options: */
+      esModuleInterop: false,
+      forceConsistentCasingInFileNames: true,
+      isolatedModules: true,
+      verbatimModuleSyntax: true,
+      skipLibCheck: true
+    },
+    // include: ['src', 'test', './moduleTypes.d.ts'],
+    // exclude: ['dist', 'examples', 'playground', 'test/fixture'],
+    include: [...include],
+    exclude: [...exclude]
+  };
+  const tsConfig = defu(
+    silgi.options.typescript?.tsConfig,
+    silgi.options.preset === "npm-package" ? npmPackageTsConfig : userTsConfig
+  );
+  tsConfig.compilerOptions ||= {};
+  tsConfig.compilerOptions.paths ||= {};
+  tsConfig.include ||= [];
+  for (const alias in tsConfig.compilerOptions.paths) {
+    const paths = tsConfig.compilerOptions.paths[alias];
+    tsConfig.compilerOptions.paths[alias] = await Promise.all(
+      paths.map(async (path) => {
+        if (!isAbsolute(path)) {
+          return path;
+        }
+        const stats = await promises.stat(path).catch(
+          () => null
+          /* file does not exist */
+        );
+        return relativeWithDot(
+          tsconfigDir,
+          stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path
+        );
+      })
+    );
+  }
+  const references = [];
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    if (id === "./src" && silgi.options.preset === "npm-package") {
+      id = resolve(silgi.options.rootDir);
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.rootDir }).catch(() => null);
+    references.push({ types: pkg?.name || id });
+  }));
+  const declarations = [];
+  await silgi.callHook("prepare:types", { references, declarations, tsConfig });
+  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
+  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
+  const _declarations = [
+    ...references.map((ref) => {
+      if ("path" in ref && isAbsolute(ref.path)) {
+        ref.path = relative(silgi.options.build.dir, ref.path);
+      }
+      return `/// <reference ${renderAttrs(ref)} />`;
+    }),
+    ...declarations,
+    "",
+    "export {}",
+    ""
+  ];
+  return {
+    declarations: _declarations,
+    tsConfig
+  };
+}
+
+export { getDirectory, silgiGenerateType };

package/dist/cli/core/app.mjs

@@ -0,0 +1,92 @@
+import { mkdirSync, existsSync, writeFileSync, promises } from 'node:fs';
+import { resolve, dirname } from 'pathe';
+import { normalizeTemplate, useLogger } from 'silgi/kit';
+import * as templates from './templates.mjs';
+import { pluginsDeclaration } from './templates.mjs';
+
+const postTemplates = [
+  pluginsDeclaration.filename
+];
+const logger = useLogger("silgi");
+async function generateApp(app, options = {}) {
+  app.templates = Object.values(templates).concat(app.options.build.templates);
+  await app.callHook("app:templates", app);
+  app.templates = app.templates.map((tmpl) => {
+    const dir = tmpl.where === ".silgi" ? app.options.build.dir : tmpl.where === "server" ? app.options.silgi.serverDir : tmpl.where === "client" ? app.options.silgi.clientDir : app.options.silgi.vfsDir;
+    return normalizeTemplate(tmpl, dir);
+  });
+  const filteredTemplates = {
+    pre: [],
+    post: []
+  };
+  for (const template of app.templates) {
+    if (options.filter && !options.filter(template)) {
+      continue;
+    }
+    const key = template.filename && postTemplates.includes(template.filename) ? "post" : "pre";
+    filteredTemplates[key].push(template);
+  }
+  const templateContext = { app };
+  const writes = [];
+  const dirs = /* @__PURE__ */ new Set();
+  const changedTemplates = [];
+  async function processTemplate(template) {
+    const dir = template.where === ".silgi" ? app.options.build.dir : template.where === "server" ? app.options.silgi.serverDir : template.where === "client" ? app.options.silgi.clientDir : app.options.silgi.vfsDir;
+    const fullPath = template.dst || resolve(dir, template.filename);
+    const start = performance.now();
+    const contents = await compileTemplate(template, templateContext).catch((e) => {
+      logger.error(`Could not compile template \`${template.filename}\`.`);
+      logger.error(e);
+      throw e;
+    });
+    template.modified = true;
+    if (template.modified) {
+      changedTemplates.push(template);
+    }
+    const perf = performance.now() - start;
+    const setupTime = Math.round(perf * 100) / 100;
+    if (app.options.debug || setupTime > 500) {
+      logger.info(`Compiled \`${template.filename}\` in ${setupTime}ms`);
+    }
+    if (template.modified && template.write) {
+      dirs.add(dirname(fullPath));
+      if (template.skipIfExists && existsSync(fullPath)) {
+        return;
+      }
+      writes.push(() => writeFileSync(fullPath, contents, "utf8"));
+    }
+  }
+  await Promise.allSettled(filteredTemplates.pre.map(processTemplate));
+  await Promise.allSettled(filteredTemplates.post.map(processTemplate));
+  for (const dir of dirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+  for (const write of writes) {
+    if (!app.errors.length) {
+      write();
+    }
+  }
+  if (changedTemplates.length) {
+    await app.callHook("app:templatesGenerated", app, changedTemplates, options);
+  }
+}
+async function compileTemplate(template, ctx) {
+  delete ctx.utils;
+  if (template.src) {
+    try {
+      return await promises.readFile(template.src, "utf-8");
+    } catch (err) {
+      logger.error(`[nuxt] Error reading template from \`${template.src}\``);
+      throw err;
+    }
+  }
+  if (template.getContents) {
+    return template.getContents({
+      ...ctx,
+      options: template.options
+    });
+  }
+  throw new Error(`[nuxt] Invalid template. Templates must have either \`src\` or \`getContents\`: ${JSON.stringify(template)}`);
+}
+
+export { generateApp, logger };

package/dist/cli/core/devServer.mjs

@@ -0,0 +1,8 @@
+import { useSilgiCLI } from 'silgi';
+
+async function reloadScan(path, _stats) {
+  const silgi = useSilgiCLI();
+  await silgi.callHook("reload:scan", path, _stats);
+}
+
+export { reloadScan };

package/dist/cli/core/env.mjs

@@ -0,0 +1,76 @@
+import { existsSync, promises } from 'node:fs';
+import * as dotenv from 'dotenv';
+import { resolve } from 'pathe';
+
+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;
+}
+async function loadDotenv(options) {
+  const environment = /* @__PURE__ */ Object.create(null);
+  const dotenvFile = resolve(options.cwd, options.fileName);
+  if (existsSync(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;
+}
+function interpolate(target, source = {}, parse = (v) => v) {
+  function getValue(key) {
+    return source[key] === void 0 ? target[key] : source[key];
+  }
+  function interpolate2(value, parents = []) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const matches = value.match(/(.?\$\{?[\w:]*\}?)/g) || [];
+    return parse(
+      matches.reduce((newValue, match) => {
+        const parts = /(.?)\$\{?([\w:]+)?\}?/.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)
+    );
+  }
+  for (const key in target) {
+    target[key] = interpolate2(getValue(key));
+  }
+}
+
+export { loadDotenv, setupDotenv };