@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/clients/lsp/launch.js

@@ -1,468 +0,0 @@
-import { execFileSync, spawn as nodeSpawn } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { isTestMode } from "../env-utils.js";
-import { getGlobalDmLensDir } from "../file-utils.js";
-import { getGlobalDmLensLogDir } from "../probe-home-state.js";
-import { isFullyQualified } from "../path-utils.js";
-import { findGlobalBinary } from "../package-manager.js";
-import { redactSecrets } from "../redact/secrets.js";
-import { classifySpawnFailure, holdOwnChildPid, isOwnLiveChild, SpawnFailureError } from "../safe-spawn.js";
-import { getRubyVersionDirNamesAsync } from "./ruby-drive-dirs.js";
-const isWindows = process.platform === "win32";
-function computeNeedsShell(resolvedCommand) {
-  return isWindows && (resolvedCommand.includes(" ") || /\.(cmd|bat)$/i.test(resolvedCommand) || !/\.(exe|cmd|bat)$/i.test(resolvedCommand));
-}
-const DEFAULT_STARTUP_FAILURE_WINDOW_MS = 50;
-const WINDOWS_NAV_STARTUP_FAILURE_WINDOW_MS = 500;
-const SESSIONSTART_LOG_DIR = getGlobalDmLensLogDir();
-const SESSIONSTART_LOG = path.join(SESSIONSTART_LOG_DIR, "sessionstart.log");
-const DM_LENS_BIN_DIR = path.join(getGlobalDmLensDir(), "bin");
-const DM_LENS_TOOLS_BIN_DIR = path.join(getGlobalDmLensDir(), "tools", "node_modules", ".bin");
-function logSessionStart(msg) {
-  if (isTestMode()) {
-    return;
-  }
-  const line = redactSecrets(`[${new Date().toISOString()}] ${msg}
-`);
-  try {
-    fs.mkdirSync(SESSIONSTART_LOG_DIR, { recursive: true });
-    fs.appendFileSync(SESSIONSTART_LOG, line);
-  } catch {}
-}
-function compactLogValue(value, max = 280) {
-  const normalized = value.replace(/\s+/g, " ").trim();
-  if (!normalized)
-    return "";
-  return normalized.length > max ? `${normalized.slice(0, max)}...` : normalized;
-}
-function delimiterForPlatform(platform) {
-  return platform === "win32" ? ";" : ":";
-}
-function splitPathEntries(value, delimiter) {
-  if (!value)
-    return [];
-  return value.split(delimiter).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-}
-function normalizePathEntry(entry, platform) {
-  if (platform !== "win32")
-    return path.posix.normalize(entry);
-  return path.win32.normalize(entry).toLowerCase();
-}
-export function combinePathValuesForPlatform(values, platform = process.platform) {
-  const unique = [];
-  const seen = new Set;
-  const delimiter = delimiterForPlatform(platform);
-  for (const value of values) {
-    for (const entry of splitPathEntries(value, delimiter)) {
-      const key = normalizePathEntry(entry, platform);
-      if (seen.has(key))
-        continue;
-      seen.add(key);
-      unique.push(entry);
-    }
-  }
-  return unique.join(delimiter);
-}
-function resolvePathValue(env) {
-  return combinePathValuesForPlatform([env.PATH, env.Path, env.path]);
-}
-export function runStderrGuardedProbe(command, args) {
-  try {
-    const { execFileSync } = require("node:child_process");
-    const out = execFileSync(command, args, {
-      timeout: 3000,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return out.trim();
-  } catch {
-    return "";
-  }
-}
-function readWindowsRegistryPath() {
-  return runStderrGuardedProbe("powershell.exe", [
-    "-NoProfile",
-    "-NonInteractive",
-    "-Command",
-    "[System.Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path','User')"
-  ]);
-}
-let _liveWindowsPath = null;
-function getLiveWindowsPath() {
-  if (_liveWindowsPath === null) {
-    _liveWindowsPath = readWindowsRegistryPath();
-  }
-  return _liveWindowsPath;
-}
-async function buildAugmentedPath(basePath) {
-  const candidates = [];
-  const nodeDir = path.dirname(process.execPath);
-  if (nodeDir) {
-    candidates.push(nodeDir);
-  }
-  if (isWindows) {
-    const home = os.homedir();
-    const driveRoot = path.parse(home).root;
-    candidates.push(path.join(home, ".cargo", "bin"));
-    candidates.push(path.join(home, "go", "bin"));
-    candidates.push(path.join(home, ".dotnet", "tools"));
-    candidates.push(DM_LENS_BIN_DIR);
-    candidates.push(DM_LENS_TOOLS_BIN_DIR);
-    candidates.push(path.join(driveRoot, "Program Files", "Go", "bin"));
-    candidates.push(path.join(driveRoot, "Go", "bin"));
-    for (const entry of await getRubyVersionDirNamesAsync(driveRoot)) {
-      candidates.push(path.join(driveRoot, entry, "bin"));
-    }
-  }
-  const effectiveBase = isWindows ? combinePathValuesForPlatform([basePath, getLiveWindowsPath()]) : basePath;
-  const existing = new Set;
-  for (const entry of splitPathEntries(effectiveBase, path.delimiter)) {
-    if (!entry)
-      continue;
-    existing.add(normalizePathEntry(entry, process.platform));
-  }
-  const toAppend = [];
-  for (const candidate of candidates) {
-    if (!candidate || !fs.existsSync(candidate))
-      continue;
-    const normalized = normalizePathEntry(candidate, process.platform);
-    if (existing.has(normalized))
-      continue;
-    toAppend.push(candidate);
-    existing.add(normalized);
-  }
-  if (toAppend.length === 0)
-    return basePath ?? "";
-  if (!basePath)
-    return toAppend.join(path.delimiter);
-  return `${basePath}${path.delimiter}${toAppend.join(path.delimiter)}`;
-}
-export function isCmdShimValid(cmdPath) {
-  try {
-    const content = fs.readFileSync(cmdPath, "utf-8");
-    const match = content.match(/"%~dp0[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
-    if (!match)
-      return true;
-    const relPath = match[1].replace(/[/\\]/g, path.sep);
-    const target = path.resolve(path.dirname(cmdPath), "..", relPath);
-    return fs.existsSync(target);
-  } catch {
-    return true;
-  }
-}
-function bypassPs1OnWindows(ps1Path, args) {
-  const cmdPath = `${ps1Path.slice(0, -4)}.cmd`;
-  if (fs.existsSync(cmdPath)) {
-    return { command: cmdPath, args, needsShell: true };
-  }
-  try {
-    const content = fs.readFileSync(ps1Path, "utf-8");
-    const match = content.match(/"\$basedir[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
-    if (match) {
-      const relPath = match[1].replace(/[/\\]/g, path.sep);
-      const jsPath = path.resolve(path.dirname(ps1Path), "..", relPath);
-      if (fs.existsSync(jsPath)) {
-        return {
-          command: process.execPath,
-          args: [jsPath, ...args],
-          needsShell: false
-        };
-      }
-    }
-  } catch {}
-  return;
-}
-function findBinaryOnPath(command, env) {
-  try {
-    const result = execFileSync(isWindows ? "where" : "which", [command], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      env,
-      timeout: 5000
-    }).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    for (const candidate of result) {
-      if (fs.existsSync(candidate)) {
-        return candidate;
-      }
-    }
-  } catch {}
-  return;
-}
-function trySpawn(command, args, cwd, env, needsShell) {
-  let proc;
-  if (needsShell) {
-    const escapeCmdArg = (s) => {
-      const escaped = s.replace(/([&|<>^()!])/g, "^$1");
-      return /[\s"]/.test(escaped) ? `"${escaped.replace(/"/g, '""')}"` : escaped;
-    };
-    const shellCommand = `"${command}" ${args.map(escapeCmdArg).join(" ")}`;
-    proc = nodeSpawn(shellCommand, [], {
-      cwd,
-      env,
-      stdio: ["pipe", "pipe", "pipe"],
-      detached: !isWindows,
-      windowsHide: true,
-      shell: true
-    });
-  } else {
-    proc = nodeSpawn(command, args, {
-      cwd,
-      env,
-      stdio: ["pipe", "pipe", "pipe"],
-      detached: !isWindows,
-      windowsHide: isWindows
-    });
-  }
-  if (!proc.stdin || !proc.stdout || !proc.stderr) {
-    throw new Error(`Failed to spawn LSP server: ${command}`);
-  }
-  if (proc.exitCode !== null || proc.killed) {
-    throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` + `The binary may be missing or corrupted.`);
-  }
-  holdOwnChildPid(proc.pid, "lsp-spawn");
-  return proc;
-}
-function unrefLspProcessHandles(proc) {
-  try {
-    proc.unref();
-  } catch {}
-  for (const stream of [proc.stdin, proc.stdout, proc.stderr]) {
-    try {
-      stream?.unref?.();
-    } catch {}
-  }
-}
-function _attachErrorHandler(proc, context, logContext, rejectOnImmediateError) {
-  let stderrPreview = "";
-  let closeLogged = false;
-  const onStderr = (chunk) => {
-    if (stderrPreview.length >= 4000)
-      return;
-    stderrPreview += chunk.toString();
-  };
-  proc.stderr?.on("data", onStderr);
-  proc.on("error", (err) => {
-    if (logContext) {
-      logSessionStart("lsp process " + context + ": spawn-error command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + " error=" + err.message + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
-    }
-    if (rejectOnImmediateError && logContext) {
-      classifySpawnFailure(err, {
-        command: logContext.command,
-        cwd: logContext.cwd
-      }).then(rejectOnImmediateError);
-    }
-  });
-  proc.on("close", (code, signal) => {
-    if (closeLogged)
-      return;
-    closeLogged = true;
-    proc.stderr?.off("data", onStderr);
-    if (code !== 0 && code !== null) {
-      if (logContext) {
-        logSessionStart("lsp process " + context + ": closed code=" + code + (signal ? " signal=" + signal : "") + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
-      }
-    } else if (signal && logContext) {
-      logSessionStart("lsp process " + context + ": closed signal=" + signal + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
-    }
-  });
-}
-export async function launchLSP(command, args = [], options = {}) {
-  const cwd = String(options.cwd ?? process.cwd());
-  const mergedEnv = { ...process.env, ...options.env };
-  const augmentedPath = await buildAugmentedPath(resolvePathValue(mergedEnv));
-  const env = {
-    ...mergedEnv,
-    PATH: augmentedPath,
-    ...isWindows ? { Path: augmentedPath } : {}
-  };
-  const isRelativePath = !isFullyQualified(command) && (command.includes(path.sep) || command.includes("/"));
-  const explicitCommand = isRelativePath ? path.resolve(cwd, command) : command;
-  const resolvedCommand = !isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/") ? findBinaryOnPath(command, env) ?? explicitCommand : explicitCommand;
-  let needsShell = computeNeedsShell(resolvedCommand);
-  let spawnCommand = resolvedCommand;
-  if (!isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/")) {
-    const globalBinPath = await findGlobalBinary(command);
-    if (globalBinPath) {
-      spawnCommand = globalBinPath;
-      needsShell = computeNeedsShell(spawnCommand);
-    }
-  }
-  if (isWindows && /\.(cmd|bat)$/i.test(spawnCommand) && !isCmdShimValid(spawnCommand)) {
-    logSessionStart(`lsp cmd-shim-invalid: ${spawnCommand} target missing — skipping candidate`);
-    const cause = Object.assign(new Error(`LSP .cmd shim target not found: ${spawnCommand}`), { code: "ENOENT" });
-    throw await classifySpawnFailure(cause, { command, cwd });
-  }
-  if (isWindows && /\.ps1$/i.test(spawnCommand)) {
-    const bypass = bypassPs1OnWindows(spawnCommand, args);
-    if (bypass) {
-      logSessionStart(`lsp ps1-bypass: ${spawnCommand} → ${bypass.command} shell=${bypass.needsShell}`);
-      spawnCommand = bypass.command;
-      args = bypass.args;
-      needsShell = bypass.needsShell;
-    } else {
-      logSessionStart(`lsp ps1-bypass: no .cmd or JS entry found for ${spawnCommand}, spawn may hang`);
-    }
-  }
-  let proc;
-  try {
-    proc = trySpawn(spawnCommand, args, cwd, env, needsShell);
-  } catch (err) {
-    if (!isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/")) {
-      const globalBinPath = await findGlobalBinary(command);
-      if (globalBinPath && globalBinPath !== spawnCommand) {
-        const needsShellGlobal = computeNeedsShell(globalBinPath);
-        proc = trySpawn(globalBinPath, args, cwd, env, needsShellGlobal);
-      } else {
-        throw await classifySpawnFailure(err, { command, cwd });
-      }
-    } else {
-      throw await classifySpawnFailure(err, { command, cwd });
-    }
-  }
-  if (!proc.stdin || !proc.stdout || !proc.stderr) {
-    throw new Error(`Failed to spawn LSP server: ${command}`);
-  }
-  if (proc.exitCode !== null || proc.killed) {
-    throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` + `The binary may be missing or corrupted.`);
-  }
-  logSessionStart(`lsp launch: command=${command} resolved=${spawnCommand} args=${JSON.stringify(args)} cwd=${cwd} shell=${needsShell ? "true" : "false"} pid=${proc.pid ?? 0}`);
-  const formatStartupStderr = (stderr) => {
-    const normalized = compactLogValue(stderr);
-    if (!normalized)
-      return "";
-    return ` stderr=${normalized}`;
-  };
-  let startupStderr = "";
-  const onStartupStderr = (chunk) => {
-    if (startupStderr.length >= 4000)
-      return;
-    startupStderr += chunk.toString();
-  };
-  proc.stderr?.on("data", onStartupStderr);
-  try {
-    await new Promise((resolve, reject) => {
-      let settled = false;
-      proc.on("error", (err) => {
-        if (!settled) {
-          settled = true;
-          classifySpawnFailure(err, { command, cwd }).then((failure) => {
-            const detail = formatStartupStderr(startupStderr);
-            reject(detail ? new SpawnFailureError(failure.kind, `${failure.message}${detail}`, failure.cause) : failure);
-          });
-        }
-      });
-      proc.on("exit", (code) => {
-        if (!settled && code !== null) {
-          settled = true;
-          const isWindowsCmd = isWindows && command.endsWith(".cmd");
-          const errorMsg = isWindowsCmd && code === 1 ? `npm .cmd shim failed (underlying binary not installed). Run 'npm install' in this project or use a global installation.` : `The binary may be missing or corrupted.`;
-          reject(new Error(`LSP server ${command} exited immediately with code ${code}. ${errorMsg}${formatStartupStderr(startupStderr)}`));
-        }
-      });
-      const startupFailureWindowMs = (() => {
-        if (options?.startupFailureWindowMs) {
-          return options.startupFailureWindowMs;
-        }
-        if (isWindows && needsShell) {
-          return WINDOWS_NAV_STARTUP_FAILURE_WINDOW_MS;
-        }
-        return DEFAULT_STARTUP_FAILURE_WINDOW_MS;
-      })();
-      setTimeout(() => {
-        if (!settled) {
-          settled = true;
-          resolve();
-        }
-      }, startupFailureWindowMs);
-    });
-  } finally {
-    proc.stderr?.off("data", onStartupStderr);
-  }
-  _attachErrorHandler(proc, command, {
-    command: spawnCommand,
-    args,
-    cwd,
-    pid: proc.pid ?? 0
-  });
-  unrefLspProcessHandles(proc);
-  return {
-    process: proc,
-    stdin: proc.stdin,
-    stdout: proc.stdout,
-    stderr: proc.stderr,
-    pid: proc.pid ?? 0,
-    command: spawnCommand,
-    args
-  };
-}
-export async function launchViaNode(scriptPath, args = [], options = {}) {
-  return launchLSP(process.execPath, [scriptPath, ...args], options);
-}
-export async function launchViaPython(moduleName, args = [], options = {}) {
-  const pythonCmd = process.platform === "win32" ? "py" : "python3";
-  return launchLSP(pythonCmd, ["-m", moduleName, ...args], options);
-}
-export async function stopLSP(handle) {
-  if (handle.process.exitCode !== null || handle.process.signalCode !== null) {
-    return;
-  }
-  return new Promise((resolve) => {
-    let settled = false;
-    let forceTimeout;
-    let giveUpTimeout;
-    const done = () => {
-      if (settled)
-        return;
-      settled = true;
-      if (forceTimeout)
-        clearTimeout(forceTimeout);
-      if (giveUpTimeout)
-        clearTimeout(giveUpTimeout);
-      handle.process.off("exit", done);
-      handle.process.off("error", done);
-      resolve();
-    };
-    handle.process.once("exit", done);
-    handle.process.once("error", done);
-    const killWindowsTree = () => {
-      if (!isWindows)
-        return false;
-      if (!isOwnLiveChild(handle.pid, "lsp-stop-windows-tree", handle.process))
-        return false;
-      try {
-        const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
-        const killer = nodeSpawn(taskkill, ["/F", "/T", "/PID", String(handle.pid)], {
-          shell: false,
-          windowsHide: true
-        });
-        killer.once("error", done);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    try {
-      if (!killWindowsTree()) {
-        handle.process.kill("SIGTERM");
-      }
-    } catch {
-      done();
-      return;
-    }
-    forceTimeout = setTimeout(() => {
-      if (settled)
-        return;
-      try {
-        if (!killWindowsTree()) {
-          handle.process.kill("SIGKILL");
-        }
-      } catch {
-        done();
-        return;
-      }
-      giveUpTimeout = setTimeout(done, 500);
-    }, 5000);
-  });
-}

package/extensions/dm-lens/dist/clients/lsp/lombok.js

@@ -1,146 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-const LOMBOK_ENV_KEYS = ["DM_LENS_LOMBOK_JAR", "LOMBOK_JAR"];
-const LOMBOK_PROJECT_FILES = [
-  "lombok.config",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts",
-  path.join("gradle", "libs.versions.toml")
-];
-function fileExists(filePath) {
-  if (!filePath)
-    return false;
-  try {
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function readTextIfSmall(filePath, maxBytes = 512 * 1024) {
-  try {
-    const stat = fs.statSync(filePath);
-    if (!stat.isFile() || stat.size > maxBytes)
-      return "";
-    return fs.readFileSync(filePath, "utf-8");
-  } catch {
-    return "";
-  }
-}
-function containsLombokDependency(text) {
-  return /\borg\.projectlombok\b/i.test(text) || /<artifactId>\s*lombok\s*<\/artifactId>/i.test(text) || /\b(annotationProcessor|compileOnly|testCompileOnly|testAnnotationProcessor)\b[^\n]*\blombok\b/i.test(text);
-}
-export function hasLombokProject(root) {
-  const lombokConfig = path.join(root, "lombok.config");
-  if (fileExists(lombokConfig))
-    return true;
-  for (const name of LOMBOK_PROJECT_FILES) {
-    if (name === "lombok.config")
-      continue;
-    const text = readTextIfSmall(path.join(root, name));
-    if (text && containsLombokDependency(text))
-      return true;
-  }
-  return false;
-}
-function envJarCandidate(env) {
-  for (const key of LOMBOK_ENV_KEYS) {
-    const value = env[key]?.trim();
-    if (fileExists(value))
-      return path.resolve(value);
-  }
-  return;
-}
-function localJarCandidates(root) {
-  return [
-    path.join(root, "lombok.jar"),
-    path.join(root, ".lombok", "lombok.jar"),
-    path.join(root, "lib", "lombok.jar"),
-    path.join(root, "libs", "lombok.jar")
-  ];
-}
-function newestExistingJar(candidates) {
-  let best;
-  for (const candidate of candidates) {
-    try {
-      const stat = fs.statSync(candidate);
-      if (!stat.isFile())
-        continue;
-      if (!best || stat.mtimeMs > best.mtimeMs) {
-        best = { filePath: candidate, mtimeMs: stat.mtimeMs };
-      }
-    } catch {}
-  }
-  return best?.filePath;
-}
-function mavenLocalLombokJar(home = os.homedir()) {
-  const base = path.join(home, ".m2", "repository", "org", "projectlombok", "lombok");
-  let versions = [];
-  try {
-    versions = fs.readdirSync(base);
-  } catch {
-    return;
-  }
-  return newestExistingJar(versions.map((version) => path.join(base, version, `lombok-${version}.jar`)));
-}
-function gradleCacheLombokJar(home = os.homedir()) {
-  const base = path.join(home, ".gradle", "caches", "modules-2", "files-2.1", "org.projectlombok", "lombok");
-  const candidates = [];
-  let versions = [];
-  try {
-    versions = fs.readdirSync(base);
-  } catch {
-    return;
-  }
-  for (const version of versions) {
-    const versionDir = path.join(base, version);
-    let hashes = [];
-    try {
-      hashes = fs.readdirSync(versionDir);
-    } catch {
-      continue;
-    }
-    for (const hash of hashes) {
-      candidates.push(path.join(versionDir, hash, `lombok-${version}.jar`));
-    }
-  }
-  return newestExistingJar(candidates);
-}
-export function resolveLombokJar(root, env = process.env) {
-  const explicit = envJarCandidate(env);
-  if (explicit)
-    return explicit;
-  return newestExistingJar(localJarCandidates(root)) ?? mavenLocalLombokJar() ?? gradleCacheLombokJar();
-}
-export function hasLombokJavaAgent(jvmArgs) {
-  return /(^|\s)-javaagent:(?:"[^"]*lombok[^"]*\.jar"|\S*lombok\S*\.jar)/i.test(jvmArgs ?? "");
-}
-function appendJvmArg(existing, next) {
-  const trimmed = existing?.trim();
-  return trimmed ? `${trimmed} ${next}` : next;
-}
-function resolveLombokJavaAgentArg(root, baseEnv = process.env) {
-  if (baseEnv.DM_LENS_JAVA_LOMBOK === "0")
-    return;
-  if (hasLombokJavaAgent(baseEnv.JDTLS_JVM_ARGS))
-    return;
-  const explicitJar = envJarCandidate(baseEnv);
-  if (!explicitJar && !hasLombokProject(root))
-    return;
-  const jar = explicitJar ?? resolveLombokJar(root, baseEnv);
-  return jar ? `-javaagent:${jar}` : undefined;
-}
-export function createLombokJdtlsArgs(root, baseEnv = process.env) {
-  const javaAgent = resolveLombokJavaAgentArg(root, baseEnv);
-  return javaAgent ? [`--jvm-arg=${javaAgent}`] : [];
-}
-export function createLombokJdtlsEnv(root, baseEnv = process.env) {
-  const javaAgent = resolveLombokJavaAgentArg(root, baseEnv);
-  if (!javaAgent)
-    return;
-  return {
-    ...baseEnv,
-    JDTLS_JVM_ARGS: appendJvmArg(baseEnv.JDTLS_JVM_ARGS, javaAgent)
-  };
-}

package/extensions/dm-lens/dist/clients/lsp/path-utils.js

@@ -1 +0,0 @@
-export { isUnderDir, normalizeEphemeralMapKey, normalizeMapKey, pathsEqual, uriToDiskPath, uriToPath } from "../path-utils.js";