@ai-setting/roy-agent-core 1.4.12 → 1.4.14

package/dist/{config/index.js → shared/@ai-setting/roy-agent-core-fvd9g6k8.js}

@@ -1,528 +1,16 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// packages/core/src/env/hook/types.ts
-function createHook(meta, fn) {
-  return {
-    ...meta,
-    execute: fn
-  };
-}
-function createPriorityHook(name, fn, priority) {
-  return createHook({ name, priority }, fn);
-}
-// packages/core/src/env/hook/hook-manager.ts
-class HookManager {
-  _hooks = new Map;
-  componentName;
-  componentVersion;
-  defaultPriority;
-  constructor(options = {}) {
-    this.componentName = options.componentName ?? "unknown";
-    this.componentVersion = options.componentVersion ?? "0.0.0";
-    this.defaultPriority = options.defaultPriority ?? 0;
-  }
-  register(hookPoint, hook) {
-    const hooks = this.getOrCreateHooks(hookPoint);
-    hooks.push(hook);
-  }
-  registerMany(hookPoint, hooks) {
-    const hookList = this.getOrCreateHooks(hookPoint);
-    hookList.push(...hooks);
-  }
-  unregister(hookPoint, name) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks)
-      return false;
-    const index = hooks.findIndex((h) => h.name === name);
-    if (index === -1)
-      return false;
-    hooks.splice(index, 1);
-    return true;
-  }
-  unregisterAll(hookPoint) {
-    this._hooks.delete(hookPoint);
-  }
-  async execute(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0)
-      return;
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    for (const hook of sortedHooks) {
-      await this.safeExecute(hook, ctx);
-    }
-  }
-  async executeAndCollect(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0)
-      return [];
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    const results = [];
-    for (const hook of sortedHooks) {
-      const result = await this.safeExecuteAndReturn(hook, ctx);
-      if (result !== undefined) {
-        results.push(result);
-      }
-    }
-    return results;
-  }
-  count(hookPoint) {
-    return this._hooks.get(hookPoint)?.length ?? 0;
-  }
-  clear() {
-    this._hooks.clear();
-  }
-  getHookPoints() {
-    return Array.from(this._hooks.keys());
-  }
-  hasHooks(hookPoint) {
-    return this.count(hookPoint) > 0;
-  }
-  setComponentInfo(name, version) {
-    this.componentName = name;
-    this.componentVersion = version;
-  }
-  get hooks() {
-    return this._hooks;
-  }
-  async executeWithIntervention(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0) {
-      return { stopped: false, results: [] };
-    }
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    const results = [];
-    let stopped = false;
-    let action;
-    for (const hook of sortedHooks) {
-      if (stopped)
-        break;
-      const result = await this.safeExecuteAndReturn(hook, ctx);
-      results.push(result);
-      if (result && typeof result === "object" && "stopped" in result) {
-        const hookResult = result;
-        if (hookResult.stopped) {
-          stopped = true;
-          action = hookResult.action;
-        }
-      }
-    }
-    return { stopped, action, results };
-  }
-  getOrCreateHooks(hookPoint) {
-    let hooks = this._hooks.get(hookPoint);
-    if (!hooks) {
-      hooks = [];
-      this._hooks.set(hookPoint, hooks);
-    }
-    return hooks;
-  }
-  sortHooks(hooks) {
-    return [...hooks].sort((a, b) => {
-      const priorityA = a.priority ?? this.defaultPriority;
-      const priorityB = b.priority ?? this.defaultPriority;
-      return priorityA - priorityB;
-    });
-  }
-  createContext(hookPoint, data, metadata, phase) {
-    return {
-      component: {
-        name: this.componentName,
-        version: this.componentVersion
-      },
-      data,
-      metadata,
-      phase,
-      hookPoint
-    };
-  }
-  async safeExecute(hook, ctx) {
-    try {
-      await hook.execute(ctx);
-    } catch (error) {
-      console.error(`Hook "${hook.name}" failed:`, error);
-    }
-  }
-  async safeExecuteAndReturn(hook, ctx) {
-    try {
-      return await hook.execute(ctx);
-    } catch (error) {
-      console.error(`Hook "${hook.name}" failed:`, error);
-      return;
-    }
-  }
-}
-// packages/core/src/env/hook/global-hook-manager.ts
-var globalHookManager = new HookManager;
-var AgentHookPoints = {
-  BEFORE_START: "agent:before.start",
-  BEFORE_LLM: "agent:before.llm",
-  AFTER_LLM: "agent:after.llm",
-  BEFORE_TOOL: "agent:before.tool",
-  AFTER_TOOL: "agent:after.tool",
-  ON_ITERATION: "agent:on.iteration",
-  ON_THRESHOLD: "agent:on.threshold",
-  AFTER_COMPLETE: "agent:after.complete",
-  ON_ERROR: "agent:on.error"
-};
-var LLMHookPoints = {
-  BEFORE_INVOKE: "llm:before.invoke",
-  AFTER_INVOKE: "llm:after.invoke",
-  ON_STREAM: "llm:on.stream"
-};
-var ToolHookPoints = {
-  BEFORE_EXECUTE: "tool:before.execute",
-  AFTER_EXECUTE: "tool:after.execute",
-  BEFORE_REGISTER: "tool:before.register",
-  AFTER_REGISTER: "tool:after.register",
-  ON_ERROR: "tool:on.error"
-};
-var hookPointAliases = {
-  "before.tool": "tool:before.execute",
-  "after.tool": "tool:after.execute",
-  "llm.before-invoke": "llm:before.invoke",
-  "llm.after-invoke": "llm:after.invoke",
-  "llm.stream": "llm:on.stream"
-};
-function setupAliasHooks() {
-  const originalRegister = globalHookManager.register.bind(globalHookManager);
-  globalHookManager.register = function(hookPoint, hook) {
-    originalRegister(hookPoint, hook);
-    const alias = hookPointAliases[hookPoint];
-    if (alias) {
-      originalRegister(alias, hook);
-    }
-  };
-}
-setupAliasHooks();
-async function executeAgentHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-async function executeAgentHookWithIntervention(hookPoint, data, metadata = {}) {
-  return globalHookManager.executeWithIntervention(hookPoint, data, metadata);
-}
-async function executeLLMHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-async function executeToolHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-// packages/core/src/env/component.ts
-class BaseComponent {
-  _status = "created";
-  _enabled = true;
-  env;
-  hookManager;
-  constructor() {
-    this.hookManager = new HookManager;
-  }
-  getStatus() {
-    return this._status;
-  }
-  getConfig() {
-    return {
-      name: this.name,
-      version: this.version,
-      enabled: this._enabled,
-      env: this.env
-    };
-  }
-  isEnvInitialized() {
-    return this._status !== "created";
-  }
-  setStatus(status) {
-    this._status = status;
-  }
-  getEnv() {
-    return this.env;
-  }
-  async init(config) {
-    if (config?.env) {
-      this.env = config.env;
-    }
-    this.setStatus("initializing");
-    try {
-      if (config?.name)
-        Object.defineProperty(this, "name", { value: config.name, writable: false });
-      if (config?.version)
-        Object.defineProperty(this, "version", { value: config.version, writable: false });
-    } catch {}
-    if (config?.enabled !== undefined)
-      this._enabled = config.enabled;
-    this.hookManager.setComponentInfo(this.name, this.version);
-    await this.onInit();
-    this.setStatus("running");
-  }
-  async start() {
-    if (this._started)
-      return;
-    this._started = true;
-    await this.onStart();
-    this.setStatus("running");
-  }
-  async stop() {
-    this.setStatus("stopping");
-    this.hookManager.clear();
-    await this.onStop();
-    this.setStatus("stopped");
-  }
-  async onInit() {}
-  async onStart() {}
-  async onStop() {}
-  registerHook(hookPoint, hook) {
-    this.hookManager.register(hookPoint, hook);
-  }
-  addHook(hookPoint, name, fn, priority) {
-    this.hookManager.register(hookPoint, createHook({ name, priority }, fn));
-  }
-  removeHook(hookPoint, name) {
-    return this.hookManager.unregister(hookPoint, name);
-  }
-  async executeHooks(hookPoint, data, metadata) {
-    await this.hookManager.execute(hookPoint, data, metadata);
-  }
-  getConfigComponent() {
-    return this.env?.getComponent("config");
-  }
-  getRuntimeConfig(key, defaultValue) {
-    const configComponent = this.getConfigComponent();
-    if (configComponent) {
-      const value = configComponent.get(key);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    return defaultValue;
-  }
-}
-
-// packages/core/src/env/paths.ts
-import os from "os";
-import path from "path";
-var APP_NAME = "roy-agent";
-function getXdgBase() {
-  const home = os.homedir();
-  try {
-    const xdg = __require("xdg-basedir");
-    return {
-      config: xdg.xdgConfig || path.join(home, ".config"),
-      state: xdg.xdgState || path.join(home, ".local", "state"),
-      data: xdg.xdgData || path.join(home, ".local", "share"),
-      cache: xdg.xdgCache || path.join(home, ".cache")
-    };
-  } catch {
-    return {
-      config: path.join(home, ".config"),
-      state: path.join(home, ".local", "state"),
-      data: path.join(home, ".local", "share"),
-      cache: path.join(home, ".cache")
-    };
-  }
-}
-function computeXDGPaths() {
-  const home = os.homedir();
-  const xdg = getXdgBase();
-  return {
-    home,
-    config: path.join(xdg.config, APP_NAME),
-    state: path.join(xdg.state, APP_NAME),
-    data: path.join(xdg.data, APP_NAME),
-    cache: path.join(xdg.cache, APP_NAME)
-  };
-}
-
-class XDGPathsCalculator {
-  _paths;
-  get paths() {
-    if (!this._paths) {
-      this._paths = computeXDGPaths();
-    }
-    return this._paths;
-  }
-  getPath(type) {
-    return this.paths[type];
-  }
-  getComponentPath(base, subPath) {
-    return path.join(this.paths[base], subPath);
-  }
-  reset() {
-    this._paths = undefined;
-  }
-}
-var XDG_PATHS = new XDGPathsCalculator;
-function getXDGPaths() {
-  return XDG_PATHS.paths;
-}
-function getXDGPath(type) {
-  return XDG_PATHS.getPath(type);
-}
-
-// packages/core/src/config/protocol-resolver.ts
-var PROTOCOL_PATTERN = /^\$\{([^:]+):\/\/([^:#]+)(?:#([^:-]+))?(?::-(.*))?\}$/;
-
-class ProtocolResolver {
-  _xdgDataHome;
-  readFileFn;
-  constructor(options = {}) {
-    this._xdgDataHome = options.xdgDataHome ?? ProtocolResolver.getDefaultXDGDataHome();
-    if (options.readFileFn) {
-      this.readFileFn = options.readFileFn;
-    } else {
-      const fsSync = __require("fs");
-      this.readFileFn = (path2) => fsSync.readFileSync(path2, "utf-8");
-    }
-  }
-  get xdgDataHome() {
-    return this._xdgDataHome;
-  }
-  set xdgDataHome(value) {
-    this._xdgDataHome = value;
-  }
-  static getDefaultXDGDataHome() {
-    return process.env.XDG_DATA_HOME ?? `${process.env.HOME ?? "~"}/.local/share`;
-  }
-  parse(ref) {
-    const match = ref.match(PROTOCOL_PATTERN);
-    if (!match)
-      return null;
-    const [, protocol, path2, key, defaultValue] = match;
-    if (!["file", "env"].includes(protocol))
-      return null;
-    return {
-      protocol,
-      path: path2,
-      key: key ?? "",
-      defaultValue,
-      raw: ref
-    };
-  }
-  isProtocolRef(value) {
-    return PROTOCOL_PATTERN.test(value);
-  }
-  resolve(ref) {
-    const parsed = this.parse(ref);
-    if (!parsed)
-      return null;
-    const value = this.resolveInternal(parsed);
-    if (parsed.protocol === "file" && value === undefined) {
-      return null;
-    }
-    if (value === undefined && parsed.protocol === "env" && parsed.defaultValue === undefined) {
-      return null;
-    }
-    if (value === undefined && parsed.defaultValue !== undefined) {
-      return {
-        value: parsed.defaultValue,
-        source: parsed.protocol
-      };
-    }
-    return {
-      value,
-      source: parsed.protocol
-    };
-  }
-  resolveFileRef(filePath, key) {
-    const resolvedPath = this.resolvePath(filePath);
-    try {
-      const content = this.readFileFn(resolvedPath);
-      let data;
-      try {
-        data = JSON.parse(content);
-      } catch {
-        return content;
-      }
-      return this.getNestedValue(data, key);
-    } catch {
-      return;
-    }
-  }
-  resolveInternal(ref) {
-    switch (ref.protocol) {
-      case "env":
-        return process.env[ref.path];
-      case "file":
-        return this.resolveFileRef(ref.path, ref.key);
-    }
-  }
-  resolvePath(filePath) {
-    if (filePath.startsWith("/")) {
-      return filePath;
-    }
-    if (filePath.startsWith("~")) {
-      return filePath.replace("~", process.env.HOME ?? "");
-    }
-    return `${this._xdgDataHome}/${filePath}`;
-  }
-  getNestedValue(obj, key) {
-    if (key === "$" || key === "")
-      return obj;
-    const keys = key.split(".");
-    let current = obj;
-    for (const k of keys) {
-      if (current === null || current === undefined || typeof current !== "object") {
-        return;
-      }
-      current = current[k];
-    }
-    return current;
-  }
-}
-
-// packages/core/src/config/file-source.ts
-import * as fsSync from "fs";
-import * as fsPromises from "fs/promises";
-import path2 from "path";
+import {
+  XDG_PATHS
+} from "./roy-agent-core-5my94ywp.js";
+import {
+  fromEnvKey,
+  toEnvKey
+} from "./roy-agent-core-jv3b7v9w.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-m2x48hw6.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // packages/core/src/config/config-parser.ts
 import { parse as parseJSONCInternal, ParseErrorCode } from "jsonc-parser";
@@ -633,6 +121,9 @@ function parseJSONCWithProtocols(content, resolver) {
 }
 
 // packages/core/src/config/file-source.ts
+import * as fsSync from "fs";
+import * as fsPromises from "fs/promises";
+import path from "path";
 class FileSource {
   name = "file";
   priority = 10;
@@ -787,7 +278,7 @@ class FileSource {
   }
   persistToFile() {
     try {
-      const dir = path2.dirname(this.filePath);
+      const dir = path.dirname(this.filePath);
       if (!fsSync.existsSync(dir)) {
         fsSync.mkdirSync(dir, { recursive: true });
       }
@@ -931,62 +422,6 @@ class FileSource {
   }
 }
 
-// packages/core/src/config/env-key.ts
-function toEnvKey(key, prefix) {
-  let keyNormalized = key.replace(/[.-]/g, "_");
-  keyNormalized = keyNormalized.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/_+/g, "_").toUpperCase();
-  if (prefix) {
-    const separator = prefix.endsWith("_") ? "" : "_";
-    return `${prefix}${separator}${keyNormalized}`;
-  }
-  return keyNormalized;
-}
-function fromEnvKey(envKey, prefix) {
-  if (!prefix) {
-    return envKey;
-  }
-  if (envKey.startsWith(prefix)) {
-    const afterPrefix = envKey.slice(prefix.length);
-    if (afterPrefix.startsWith("_")) {
-      return afterPrefix.slice(1);
-    }
-    return afterPrefix;
-  }
-  return envKey;
-}
-function envKeyToConfigKey(envKey, prefix, componentName) {
-  const prefixUpper = prefix.toUpperCase();
-  if (!envKey.startsWith(prefixUpper)) {
-    return;
-  }
-  const componentUpperNormalized = componentName.replace(/-/g, "_").toUpperCase();
-  let keyPart = envKey.slice(prefixUpper.length);
-  if (keyPart.startsWith("_")) {
-    keyPart = keyPart.slice(1);
-  }
-  if (!keyPart) {
-    return;
-  }
-  const firstUnderscore = keyPart.indexOf("_");
-  let restPart;
-  if (firstUnderscore === -1) {
-    restPart = keyPart;
-  } else {
-    const firstPart = keyPart.slice(0, firstUnderscore);
-    const remaining = keyPart.slice(firstUnderscore + 1);
-    if (firstPart === componentUpperNormalized) {
-      restPart = remaining;
-    } else {
-      restPart = keyPart;
-    }
-  }
-  if (!restPart) {
-    return;
-  }
-  const restPartConverted = restPart.replace(/_/g, ".");
-  return `${componentName}.${restPartConverted.toLowerCase()}`;
-}
-
 // packages/core/src/config/env-source.ts
 class EnvSource {
   name = "env";
@@ -1178,13 +613,124 @@ class EnvSource {
   }
 }
 
+// packages/core/src/config/protocol-resolver.ts
+var PROTOCOL_PATTERN = /^\$\{([^:]+):\/\/([^:#]+)(?:#([^:-]+))?(?::-(.*))?\}$/;
+
+class ProtocolResolver {
+  _xdgDataHome;
+  readFileFn;
+  constructor(options = {}) {
+    this._xdgDataHome = options.xdgDataHome ?? ProtocolResolver.getDefaultXDGDataHome();
+    if (options.readFileFn) {
+      this.readFileFn = options.readFileFn;
+    } else {
+      const fsSync2 = __require("fs");
+      this.readFileFn = (path2) => fsSync2.readFileSync(path2, "utf-8");
+    }
+  }
+  get xdgDataHome() {
+    return this._xdgDataHome;
+  }
+  set xdgDataHome(value) {
+    this._xdgDataHome = value;
+  }
+  static getDefaultXDGDataHome() {
+    return process.env.XDG_DATA_HOME ?? `${process.env.HOME ?? "~"}/.local/share`;
+  }
+  parse(ref) {
+    const match = ref.match(PROTOCOL_PATTERN);
+    if (!match)
+      return null;
+    const [, protocol, path2, key, defaultValue] = match;
+    if (!["file", "env"].includes(protocol))
+      return null;
+    return {
+      protocol,
+      path: path2,
+      key: key ?? "",
+      defaultValue,
+      raw: ref
+    };
+  }
+  isProtocolRef(value) {
+    return PROTOCOL_PATTERN.test(value);
+  }
+  resolve(ref) {
+    const parsed = this.parse(ref);
+    if (!parsed)
+      return null;
+    const value = this.resolveInternal(parsed);
+    if (parsed.protocol === "file" && value === undefined) {
+      return null;
+    }
+    if (value === undefined && parsed.protocol === "env" && parsed.defaultValue === undefined) {
+      return null;
+    }
+    if (value === undefined && parsed.defaultValue !== undefined) {
+      return {
+        value: parsed.defaultValue,
+        source: parsed.protocol
+      };
+    }
+    return {
+      value,
+      source: parsed.protocol
+    };
+  }
+  resolveFileRef(filePath, key) {
+    const resolvedPath = this.resolvePath(filePath);
+    try {
+      const content = this.readFileFn(resolvedPath);
+      let data;
+      try {
+        data = JSON.parse(content);
+      } catch {
+        return content;
+      }
+      return this.getNestedValue(data, key);
+    } catch {
+      return;
+    }
+  }
+  resolveInternal(ref) {
+    switch (ref.protocol) {
+      case "env":
+        return process.env[ref.path];
+      case "file":
+        return this.resolveFileRef(ref.path, ref.key);
+    }
+  }
+  resolvePath(filePath) {
+    if (filePath.startsWith("/")) {
+      return filePath;
+    }
+    if (filePath.startsWith("~")) {
+      return filePath.replace("~", process.env.HOME ?? "");
+    }
+    return `${this._xdgDataHome}/${filePath}`;
+  }
+  getNestedValue(obj, key) {
+    if (key === "$" || key === "")
+      return obj;
+    const keys = key.split(".");
+    let current = obj;
+    for (const k of keys) {
+      if (current === null || current === undefined || typeof current !== "object") {
+        return;
+      }
+      current = current[k];
+    }
+    return current;
+  }
+}
+
 // packages/core/src/config/config-component.ts
-import * as os2 from "os";
-import * as path3 from "path";
+import * as os from "os";
+import * as path2 from "path";
 
 class ConfigSourceNotFoundError extends Error {
-  constructor(sourceType, path4) {
-    const message = path4 ? `Config source not found: ${sourceType} at ${path4}` : `Config source not found: ${sourceType}`;
+  constructor(sourceType, path3) {
+    const message = path3 ? `Config source not found: ${sourceType} at ${path3}` : `Config source not found: ${sourceType}`;
     super(message);
     this.name = "ConfigSourceNotFoundError";
   }
@@ -1323,12 +869,12 @@ class ConfigComponent extends BaseComponent {
   pendingSources = [];
   sourceKeys = new Map;
   getXdgDataHome() {
-    return this.__xdgDataHome ?? process.env.XDG_DATA_HOME ?? path3.join(os2.homedir(), ".local", "share");
+    return this.__xdgDataHome ?? process.env.XDG_DATA_HOME ?? path2.join(os.homedir(), ".local", "share");
   }
-  setXdgDataHome(path4) {
-    this.__xdgDataHome = path4;
+  setXdgDataHome(path3) {
+    this.__xdgDataHome = path3;
     if (this.protocolResolver) {
-      this.protocolResolver.xdgDataHome = path4;
+      this.protocolResolver.xdgDataHome = path3;
     }
   }
   constructor(options = {}) {
@@ -1548,7 +1094,7 @@ class ConfigComponent extends BaseComponent {
         if (!relativePath) {
           throw new Error("File source requires relativePath");
         }
-        const isAbsolutePath = path3.isAbsolute(relativePath) || relativePath.startsWith("file://");
+        const isAbsolutePath = path2.isAbsolute(relativePath) || relativePath.startsWith("file://");
         let filePath;
         if (isAbsolutePath) {
           filePath = relativePath.startsWith("file://") ? relativePath.replace(/^file:\/\//, "") : relativePath;
@@ -1556,7 +1102,7 @@ class ConfigComponent extends BaseComponent {
           if (this.protocolResolver) {
             this.protocolResolver.xdgDataHome = this.getXdgDataHome();
           }
-          filePath = path3.join(this.getXdgDataHome(), relativePath);
+          filePath = path2.join(this.getXdgDataHome(), relativePath);
         }
         return new FileSource({
           filePath,
@@ -1655,16 +1201,5 @@ class ConfigComponent extends BaseComponent {
     return [...this.sources];
   }
 }
-export {
-  substituteProtocolRefs,
-  substituteEnvVars,
-  parseJSONCWithProtocols,
-  parseJSONCWithEnv,
-  parseJSONC,
-  MemorySource,
-  FileSource,
-  EnvSource,
-  ConfigSourceNotFoundError,
-  ConfigFileNotFoundError,
-  ConfigComponent
-};
+
+export { parseJSONC, substituteEnvVars, parseJSONCWithEnv, substituteProtocolRefs, parseJSONCWithProtocols, FileSource, EnvSource, ConfigSourceNotFoundError, ConfigFileNotFoundError, MemorySource, ConfigComponent };