@jdi-code/claude-code 1.0.3

package/dist/chunk-cejskpky.js

@@ -0,0 +1,307 @@
+// @bun
+import {
+  BashTool,
+  ShellProgressMessage,
+  UserBashInputMessage,
+  createSyntheticUserCaveatMessage,
+  createUserInterruptionMessage,
+  createUserMessage,
+  escapeXml,
+  exports_PowerShellTool,
+  init_BashTool,
+  init_PowerShellTool,
+  init_ShellProgressMessage,
+  init_UserBashInputMessage,
+  init_messages1 as init_messages,
+  init_shellToolUtils,
+  init_toolResultStorage,
+  init_xml,
+  isPowerShellToolEnabled,
+  prepareUserContent,
+  processToolResultBlock
+} from "./chunk-5frcqxsv.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-gb2q3nvc.js";
+import"./chunk-neh2frnn.js";
+import"./chunk-q6b51yc5.js";
+import"./chunk-gfkppe34.js";
+import"./chunk-kqd0e3xj.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-xe6z85xc.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-pxrffn0w.js";
+import"./chunk-0nt9md2b.js";
+import"./chunk-rn4kqfvd.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-n8sjmqba.js";
+import"./chunk-9e2kqv5g.js";
+import"./chunk-g653q217.js";
+import {
+  ThemedBox_default,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-z72st5c8.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-35x3tjnr.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-40b8p5em.js";
+import"./chunk-s0xfxkys.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-7sb5axvf.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-qz2x630m.js";
+import {
+  getInitialSettings,
+  init_settings1 as init_settings
+} from "./chunk-53nbpp47.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-fw49pe3p.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import {
+  ShellError,
+  errorMessage,
+  init_errors
+} from "./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __toCommonJS,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/processUserInput/processBashCommand.tsx
+import { randomUUID } from "crypto";
+
+// src/components/BashModeProgress.tsx
+init_ink();
+init_BashTool();
+init_UserBashInputMessage();
+init_ShellProgressMessage();
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function BashModeProgress(t0) {
+  const $ = import_compiler_runtime.c(8);
+  const {
+    input,
+    progress,
+    verbose
+  } = t0;
+  const t1 = `<bash-input>${input}</bash-input>`;
+  let t2;
+  if ($[0] !== t1) {
+    t2 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(UserBashInputMessage, {
+      addMargin: false,
+      param: {
+        text: t1,
+        type: "text"
+      }
+    }, undefined, false, undefined, this);
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  let t3;
+  if ($[2] !== progress || $[3] !== verbose) {
+    t3 = progress ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ShellProgressMessage, {
+      fullOutput: progress.fullOutput,
+      output: progress.output,
+      elapsedTimeSeconds: progress.elapsedTimeSeconds,
+      totalLines: progress.totalLines,
+      verbose
+    }, undefined, false, undefined, this) : BashTool.renderToolUseProgressMessage?.([], {
+      verbose,
+      tools: [],
+      terminalSize: undefined
+    });
+    $[2] = progress;
+    $[3] = verbose;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== t2 || $[6] !== t3) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      marginTop: 1,
+      children: [
+        t2,
+        t3
+      ]
+    }, undefined, true, undefined, this);
+    $[5] = t2;
+    $[6] = t3;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  return t4;
+}
+
+// src/utils/processUserInput/processBashCommand.tsx
+init_BashTool();
+init_analytics();
+init_errors();
+init_messages();
+
+// src/utils/shell/resolveDefaultShell.ts
+init_settings();
+function resolveDefaultShell() {
+  return getInitialSettings().defaultShell ?? "bash";
+}
+
+// src/utils/processUserInput/processBashCommand.tsx
+init_shellToolUtils();
+init_toolResultStorage();
+init_xml();
+var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
+async function processBashCommand(inputString, precedingInputBlocks, attachmentMessages, context, setToolJSX) {
+  const usePowerShell = isPowerShellToolEnabled() && resolveDefaultShell() === "powershell";
+  logEvent("tengu_input_bash", {
+    powershell: usePowerShell
+  });
+  const userMessage = createUserMessage({
+    content: prepareUserContent({
+      inputString: `<bash-input>${inputString}</bash-input>`,
+      precedingInputBlocks
+    })
+  });
+  let jsx;
+  setToolJSX({
+    jsx: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(BashModeProgress, {
+      input: inputString,
+      progress: null,
+      verbose: context.options.verbose
+    }, undefined, false, undefined, this),
+    shouldHidePromptInput: false
+  });
+  try {
+    const bashModeContext = {
+      ...context,
+      setToolJSX: (_) => {
+        jsx = _?.jsx;
+      }
+    };
+    const onProgress = (progress) => {
+      setToolJSX({
+        jsx: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(jsx_dev_runtime2.Fragment, {
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(BashModeProgress, {
+              input: inputString,
+              progress: progress.data,
+              verbose: context.options.verbose
+            }, undefined, false, undefined, this),
+            jsx
+          ]
+        }, undefined, true, undefined, this),
+        shouldHidePromptInput: false,
+        showSpinner: false
+      });
+    };
+    let PowerShellTool = null;
+    if (usePowerShell) {
+      PowerShellTool = (init_PowerShellTool(), __toCommonJS(exports_PowerShellTool)).PowerShellTool;
+    }
+    const shellTool = PowerShellTool ?? BashTool;
+    const response = PowerShellTool ? await PowerShellTool.call({
+      command: inputString,
+      dangerouslyDisableSandbox: true
+    }, bashModeContext, undefined, undefined, onProgress) : await BashTool.call({
+      command: inputString,
+      dangerouslyDisableSandbox: true
+    }, bashModeContext, undefined, undefined, onProgress);
+    const data = response.data;
+    if (!data) {
+      throw new Error("No result received from shell command");
+    }
+    const stderr = data.stderr;
+    const mapped = await processToolResultBlock(shellTool, {
+      ...data,
+      stderr: ""
+    }, randomUUID());
+    const stdout = typeof mapped.content === "string" ? mapped.content : escapeXml(data.stdout);
+    return {
+      messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
+        content: `<bash-stdout>${stdout}</bash-stdout><bash-stderr>${escapeXml(stderr)}</bash-stderr>`
+      })],
+      shouldQuery: false
+    };
+  } catch (e) {
+    if (e instanceof ShellError) {
+      if (e.interrupted) {
+        return {
+          messages: [createSyntheticUserCaveatMessage(), userMessage, createUserInterruptionMessage({
+            toolUse: false
+          }), ...attachmentMessages],
+          shouldQuery: false
+        };
+      }
+      return {
+        messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
+          content: `<bash-stdout>${escapeXml(e.stdout)}</bash-stdout><bash-stderr>${escapeXml(e.stderr)}</bash-stderr>`
+        })],
+        shouldQuery: false
+      };
+    }
+    return {
+      messages: [createSyntheticUserCaveatMessage(), userMessage, ...attachmentMessages, createUserMessage({
+        content: `<bash-stderr>Command failed: ${escapeXml(errorMessage(e))}</bash-stderr>`
+      })],
+      shouldQuery: false
+    };
+  } finally {
+    setToolJSX(null);
+  }
+}
+export {
+  processBashCommand
+};

package/dist/chunk-cfv996bs.js

@@ -0,0 +1,22 @@
+// @bun
+import {
+  require_lib
+} from "./chunk-qz2x630m.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/highlight.js@11.11.1/node_modules/highlight.js/es/index.js
+var import_lib, es_default;
+var init_es = __esm(() => {
+  import_lib = __toESM(require_lib(), 1);
+  es_default = import_lib.default;
+});
+init_es();
+var export_HighlightJS = import_lib.default;
+
+export {
+  es_default as default,
+  export_HighlightJS as HighlightJS
+};

package/dist/chunk-cgfdkzhb.js

@@ -0,0 +1,12 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/worktreeModeEnabled.ts
+function isWorktreeModeEnabled() {
+  return true;
+}
+var init_worktreeModeEnabled = () => {};
+
+export { isWorktreeModeEnabled, init_worktreeModeEnabled };

package/dist/chunk-cha1tdry.js

@@ -0,0 +1,95 @@
+// @bun
+import {
+  BASH_TOOL_NAME,
+  getAllowRules,
+  getAskRules,
+  getDenyRules,
+  init_permissions,
+  init_toolName,
+  permissionRuleSourceDisplayString
+} from "./chunk-5frcqxsv.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/permissions/shadowedRuleDetection.ts
+function isSharedSettingSource(source) {
+  return source === "projectSettings" || source === "policySettings" || source === "command";
+}
+function formatSource(source) {
+  return permissionRuleSourceDisplayString(source);
+}
+function generateFixSuggestion(shadowType, shadowingRule, shadowedRule) {
+  const shadowingSource = formatSource(shadowingRule.source);
+  const shadowedSource = formatSource(shadowedRule.source);
+  const toolName = shadowingRule.ruleValue.toolName;
+  if (shadowType === "deny") {
+    return `Remove the "${toolName}" deny rule from ${shadowingSource}, or remove the specific allow rule from ${shadowedSource}`;
+  }
+  return `Remove the "${toolName}" ask rule from ${shadowingSource}, or remove the specific allow rule from ${shadowedSource}`;
+}
+function isAllowRuleShadowedByAskRule(allowRule, askRules, options) {
+  const { toolName, ruleContent } = allowRule.ruleValue;
+  if (ruleContent === undefined) {
+    return { shadowed: false };
+  }
+  const shadowingAskRule = askRules.find((askRule) => askRule.ruleValue.toolName === toolName && askRule.ruleValue.ruleContent === undefined);
+  if (!shadowingAskRule) {
+    return { shadowed: false };
+  }
+  if (toolName === BASH_TOOL_NAME && options.sandboxAutoAllowEnabled) {
+    if (!isSharedSettingSource(shadowingAskRule.source)) {
+      return { shadowed: false };
+    }
+  }
+  return { shadowed: true, shadowedBy: shadowingAskRule, shadowType: "ask" };
+}
+function isAllowRuleShadowedByDenyRule(allowRule, denyRules) {
+  const { toolName, ruleContent } = allowRule.ruleValue;
+  if (ruleContent === undefined) {
+    return { shadowed: false };
+  }
+  const shadowingDenyRule = denyRules.find((denyRule) => denyRule.ruleValue.toolName === toolName && denyRule.ruleValue.ruleContent === undefined);
+  if (!shadowingDenyRule) {
+    return { shadowed: false };
+  }
+  return { shadowed: true, shadowedBy: shadowingDenyRule, shadowType: "deny" };
+}
+function detectUnreachableRules(context, options) {
+  const unreachable = [];
+  const allowRules = getAllowRules(context);
+  const askRules = getAskRules(context);
+  const denyRules = getDenyRules(context);
+  for (const allowRule of allowRules) {
+    const denyResult = isAllowRuleShadowedByDenyRule(allowRule, denyRules);
+    if (denyResult.shadowed) {
+      const shadowSource = formatSource(denyResult.shadowedBy.source);
+      unreachable.push({
+        rule: allowRule,
+        reason: `Blocked by "${denyResult.shadowedBy.ruleValue.toolName}" deny rule (from ${shadowSource})`,
+        shadowedBy: denyResult.shadowedBy,
+        shadowType: "deny",
+        fix: generateFixSuggestion("deny", denyResult.shadowedBy, allowRule)
+      });
+      continue;
+    }
+    const askResult = isAllowRuleShadowedByAskRule(allowRule, askRules, options);
+    if (askResult.shadowed) {
+      const shadowSource = formatSource(askResult.shadowedBy.source);
+      unreachable.push({
+        rule: allowRule,
+        reason: `Shadowed by "${askResult.shadowedBy.ruleValue.toolName}" ask rule (from ${shadowSource})`,
+        shadowedBy: askResult.shadowedBy,
+        shadowType: "ask",
+        fix: generateFixSuggestion("ask", askResult.shadowedBy, allowRule)
+      });
+    }
+  }
+  return unreachable;
+}
+var init_shadowedRuleDetection = __esm(() => {
+  init_toolName();
+  init_permissions();
+});
+
+export { detectUnreachableRules, init_shadowedRuleDetection };

package/dist/chunk-ctw5jwcd.js

@@ -0,0 +1,213 @@
+// @bun
+import {
+  init_sessionStoragePortable
+} from "./chunk-vratq94g.js";
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-tjaqa99q.js";
+import {
+  init_memoize as init_memoize2,
+  memoizeWithLRU
+} from "./chunk-d18z9pna.js";
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-vyc0rjyx.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_fsOperations,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/windowsPaths.ts
+import * as path from "path";
+import * as pathWin32 from "path/win32";
+function checkPathExists(path2) {
+  try {
+    execSync_DEPRECATED(`dir "${path2}"`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findExecutable(executable) {
+  if (executable === "git") {
+    const defaultLocations = [
+      "C:\\Program Files\\Git\\cmd\\git.exe",
+      "C:\\Program Files (x86)\\Git\\cmd\\git.exe"
+    ];
+    for (const location of defaultLocations) {
+      if (checkPathExists(location)) {
+        return location;
+      }
+    }
+  }
+  try {
+    const result = execSync_DEPRECATED(`where.exe ${executable}`, {
+      stdio: "pipe",
+      encoding: "utf8"
+    }).trim();
+    const paths = result.split(`\r
+`).filter(Boolean);
+    const cwd = getCwd().toLowerCase();
+    for (const candidatePath of paths) {
+      const normalizedPath = path.resolve(candidatePath).toLowerCase();
+      const pathDir = path.dirname(normalizedPath).toLowerCase();
+      if (pathDir === cwd || normalizedPath.startsWith(cwd + path.sep)) {
+        logForDebugging(`Skipping potentially malicious executable in current directory: ${candidatePath}`);
+        continue;
+      }
+      return candidatePath;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function setShellIfWindows() {
+  if (getPlatform() === "windows") {
+    const gitBashPath = findGitBashPath();
+    process.env.SHELL = gitBashPath;
+    logForDebugging(`Using bash path: "${gitBashPath}"`);
+  }
+}
+var findGitBashPath, windowsPathToPosixPath, posixPathToWindowsPath;
+var init_windowsPaths = __esm(() => {
+  init_memoize();
+  init_cwd();
+  init_debug();
+  init_execSyncWrapper();
+  init_memoize2();
+  init_platform();
+  findGitBashPath = memoize_default(() => {
+    if (process.env.CLAUDE_CODE_GIT_BASH_PATH) {
+      if (checkPathExists(process.env.CLAUDE_CODE_GIT_BASH_PATH)) {
+        return process.env.CLAUDE_CODE_GIT_BASH_PATH;
+      }
+      console.error(`Claude Code was unable to find CLAUDE_CODE_GIT_BASH_PATH path "${process.env.CLAUDE_CODE_GIT_BASH_PATH}"`);
+      process.exit(1);
+    }
+    const gitPath = findExecutable("git");
+    if (gitPath) {
+      const bashPath = pathWin32.join(gitPath, "..", "..", "bin", "bash.exe");
+      if (checkPathExists(bashPath)) {
+        return bashPath;
+      }
+    }
+    console.error("Claude Code on Windows requires git-bash (https://git-scm.com/downloads/win). If installed but not in PATH, set environment variable pointing to your bash.exe, similar to: CLAUDE_CODE_GIT_BASH_PATH=C:\\Program Files\\Git\\bin\\bash.exe");
+    process.exit(1);
+  });
+  windowsPathToPosixPath = memoizeWithLRU((windowsPath) => {
+    if (windowsPath.startsWith("\\\\")) {
+      return windowsPath.replace(/\\/g, "/");
+    }
+    const match = windowsPath.match(/^([A-Za-z]):[/\\]/);
+    if (match) {
+      const driveLetter = match[1].toLowerCase();
+      return "/" + driveLetter + windowsPath.slice(2).replace(/\\/g, "/");
+    }
+    return windowsPath.replace(/\\/g, "/");
+  }, (p) => p, 500);
+  posixPathToWindowsPath = memoizeWithLRU((posixPath) => {
+    if (posixPath.startsWith("//")) {
+      return posixPath.replace(/\//g, "\\");
+    }
+    const cygdriveMatch = posixPath.match(/^\/cygdrive\/([A-Za-z])(\/|$)/);
+    if (cygdriveMatch) {
+      const driveLetter = cygdriveMatch[1].toUpperCase();
+      const rest = posixPath.slice(("/cygdrive/" + cygdriveMatch[1]).length);
+      return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    const driveMatch = posixPath.match(/^\/([A-Za-z])(\/|$)/);
+    if (driveMatch) {
+      const driveLetter = driveMatch[1].toUpperCase();
+      const rest = posixPath.slice(2);
+      return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    return posixPath.replace(/\//g, "\\");
+  }, (p) => p, 500);
+});
+
+// src/utils/path.ts
+import { homedir } from "os";
+import { dirname as dirname2, isAbsolute, join as join2, normalize, relative, resolve as resolve2 } from "path";
+function expandPath(path2, baseDir) {
+  const actualBaseDir = baseDir ?? getCwd() ?? getFsImplementation().cwd();
+  if (typeof path2 !== "string") {
+    throw new TypeError(`Path must be a string, received ${typeof path2}`);
+  }
+  if (typeof actualBaseDir !== "string") {
+    throw new TypeError(`Base directory must be a string, received ${typeof actualBaseDir}`);
+  }
+  if (path2.includes("\x00") || actualBaseDir.includes("\x00")) {
+    throw new Error("Path contains null bytes");
+  }
+  const trimmedPath = path2.trim();
+  if (!trimmedPath) {
+    return normalize(actualBaseDir).normalize("NFC");
+  }
+  if (trimmedPath === "~") {
+    return homedir().normalize("NFC");
+  }
+  if (trimmedPath.startsWith("~/")) {
+    return join2(homedir(), trimmedPath.slice(2)).normalize("NFC");
+  }
+  let processedPath = trimmedPath;
+  if (getPlatform() === "windows" && trimmedPath.match(/^\/[a-z]\//i)) {
+    try {
+      processedPath = posixPathToWindowsPath(trimmedPath);
+    } catch {
+      processedPath = trimmedPath;
+    }
+  }
+  if (isAbsolute(processedPath)) {
+    return normalize(processedPath).normalize("NFC");
+  }
+  return resolve2(actualBaseDir, processedPath).normalize("NFC");
+}
+function toRelativePath(absolutePath) {
+  const relativePath = relative(getCwd(), absolutePath);
+  return relativePath.startsWith("..") ? absolutePath : relativePath;
+}
+function getDirectoryForPath(path2) {
+  const absolutePath = expandPath(path2);
+  if (absolutePath.startsWith("\\\\") || absolutePath.startsWith("//")) {
+    return dirname2(absolutePath);
+  }
+  try {
+    const stats = getFsImplementation().statSync(absolutePath);
+    if (stats.isDirectory()) {
+      return absolutePath;
+    }
+  } catch {}
+  return dirname2(absolutePath);
+}
+function containsPathTraversal(path2) {
+  return /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(path2);
+}
+function normalizePathForConfigKey(path2) {
+  const normalized = normalize(path2);
+  return normalized.replace(/\\/g, "/");
+}
+var init_path = __esm(() => {
+  init_cwd();
+  init_fsOperations();
+  init_platform();
+  init_windowsPaths();
+  init_sessionStoragePortable();
+});
+
+export { setShellIfWindows, findGitBashPath, windowsPathToPosixPath, posixPathToWindowsPath, init_windowsPaths, expandPath, toRelativePath, getDirectoryForPath, containsPathTraversal, normalizePathForConfigKey, init_path };