claude-code-best 1.0.3

package/dist/chunk-ckcagq32.js

@@ -0,0 +1,208 @@
+// @bun
+import {
+  require_httpAuthSchemes
+} from "./chunk-wzpdet3m.js";
+import {
+  require_dist_cjs as require_dist_cjs2
+} from "./chunk-n0qaeaa5.js";
+import {
+  require_client
+} from "./chunk-b4wg70y1.js";
+import {
+  require_dist_cjs
+} from "./chunk-hk9xz7gk.js";
+import {
+  __esm,
+  __require,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/fromEnvSigningName.js
+var import_client, import_httpAuthSchemes, import_property_provider, fromEnvSigningName = ({ logger, signingName } = {}) => async () => {
+  logger?.debug?.("@aws-sdk/token-providers - fromEnvSigningName");
+  if (!signingName) {
+    throw new import_property_provider.TokenProviderError("Please pass 'signingName' to compute environment variable key", { logger });
+  }
+  const bearerTokenKey = import_httpAuthSchemes.getBearerTokenEnvKey(signingName);
+  if (!(bearerTokenKey in process.env)) {
+    throw new import_property_provider.TokenProviderError(`Token not present in '${bearerTokenKey}' environment variable`, { logger });
+  }
+  const token = { token: process.env[bearerTokenKey] };
+  import_client.setTokenFeature(token, "BEARER_SERVICE_ENV_VARS", "3");
+  return token;
+};
+var init_fromEnvSigningName = __esm(() => {
+  import_client = __toESM(require_client(), 1);
+  import_httpAuthSchemes = __toESM(require_httpAuthSchemes(), 1);
+  import_property_provider = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/constants.js
+var EXPIRE_WINDOW_MS, REFRESH_MESSAGE = `To refresh this SSO session run 'aws sso login' with the corresponding profile.`;
+var init_constants = __esm(() => {
+  EXPIRE_WINDOW_MS = 5 * 60 * 1000;
+});
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/getSsoOidcClient.js
+var getSsoOidcClient = async (ssoRegion, init = {}, callerClientConfig) => {
+  const { SSOOIDCClient } = await import("./chunk-bq6x1ehp.js").then((m)=>__toESM(m.default,1));
+  const coalesce = (prop) => init.clientConfig?.[prop] ?? init.parentClientConfig?.[prop] ?? callerClientConfig?.[prop];
+  const ssoOidcClient = new SSOOIDCClient(Object.assign({}, init.clientConfig ?? {}, {
+    region: ssoRegion ?? init.clientConfig?.region,
+    logger: coalesce("logger"),
+    userAgentAppId: coalesce("userAgentAppId")
+  }));
+  return ssoOidcClient;
+};
+var init_getSsoOidcClient = () => {};
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/getNewSsoOidcToken.js
+var getNewSsoOidcToken = async (ssoToken, ssoRegion, init = {}, callerClientConfig) => {
+  const { CreateTokenCommand } = await import("./chunk-bq6x1ehp.js").then((m)=>__toESM(m.default,1));
+  const ssoOidcClient = await getSsoOidcClient(ssoRegion, init, callerClientConfig);
+  return ssoOidcClient.send(new CreateTokenCommand({
+    clientId: ssoToken.clientId,
+    clientSecret: ssoToken.clientSecret,
+    refreshToken: ssoToken.refreshToken,
+    grantType: "refresh_token"
+  }));
+};
+var init_getNewSsoOidcToken = __esm(() => {
+  init_getSsoOidcClient();
+});
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenExpiry.js
+var import_property_provider2, validateTokenExpiry = (token) => {
+  if (token.expiration && token.expiration.getTime() < Date.now()) {
+    throw new import_property_provider2.TokenProviderError(`Token is expired. ${REFRESH_MESSAGE}`, false);
+  }
+};
+var init_validateTokenExpiry = __esm(() => {
+  init_constants();
+  import_property_provider2 = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenKey.js
+var import_property_provider3, validateTokenKey = (key, value, forRefresh = false) => {
+  if (typeof value === "undefined") {
+    throw new import_property_provider3.TokenProviderError(`Value not present for '${key}' in SSO Token${forRefresh ? ". Cannot refresh" : ""}. ${REFRESH_MESSAGE}`, false);
+  }
+};
+var init_validateTokenKey = __esm(() => {
+  init_constants();
+  import_property_provider3 = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/writeSSOTokenToFile.js
+import { promises as fsPromises } from "fs";
+var import_shared_ini_file_loader, writeFile, writeSSOTokenToFile = (id, ssoToken) => {
+  const tokenFilepath = import_shared_ini_file_loader.getSSOTokenFilepath(id);
+  const tokenString = JSON.stringify(ssoToken, null, 2);
+  return writeFile(tokenFilepath, tokenString);
+};
+var init_writeSSOTokenToFile = __esm(() => {
+  import_shared_ini_file_loader = __toESM(require_dist_cjs2(), 1);
+  ({ writeFile } = fsPromises);
+});
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/fromSso.js
+var import_property_provider4, import_shared_ini_file_loader2, lastRefreshAttemptTime, fromSso = (init = {}) => async ({ callerClientConfig } = {}) => {
+  init.logger?.debug("@aws-sdk/token-providers - fromSso");
+  const profiles = await import_shared_ini_file_loader2.parseKnownFiles(init);
+  const profileName = import_shared_ini_file_loader2.getProfileName({
+    profile: init.profile ?? callerClientConfig?.profile
+  });
+  const profile = profiles[profileName];
+  if (!profile) {
+    throw new import_property_provider4.TokenProviderError(`Profile '${profileName}' could not be found in shared credentials file.`, false);
+  } else if (!profile["sso_session"]) {
+    throw new import_property_provider4.TokenProviderError(`Profile '${profileName}' is missing required property 'sso_session'.`);
+  }
+  const ssoSessionName = profile["sso_session"];
+  const ssoSessions = await import_shared_ini_file_loader2.loadSsoSessionData(init);
+  const ssoSession = ssoSessions[ssoSessionName];
+  if (!ssoSession) {
+    throw new import_property_provider4.TokenProviderError(`Sso session '${ssoSessionName}' could not be found in shared credentials file.`, false);
+  }
+  for (const ssoSessionRequiredKey of ["sso_start_url", "sso_region"]) {
+    if (!ssoSession[ssoSessionRequiredKey]) {
+      throw new import_property_provider4.TokenProviderError(`Sso session '${ssoSessionName}' is missing required property '${ssoSessionRequiredKey}'.`, false);
+    }
+  }
+  const ssoStartUrl = ssoSession["sso_start_url"];
+  const ssoRegion = ssoSession["sso_region"];
+  let ssoToken;
+  try {
+    ssoToken = await import_shared_ini_file_loader2.getSSOTokenFromFile(ssoSessionName);
+  } catch (e) {
+    throw new import_property_provider4.TokenProviderError(`The SSO session token associated with profile=${profileName} was not found or is invalid. ${REFRESH_MESSAGE}`, false);
+  }
+  validateTokenKey("accessToken", ssoToken.accessToken);
+  validateTokenKey("expiresAt", ssoToken.expiresAt);
+  const { accessToken, expiresAt } = ssoToken;
+  const existingToken = { token: accessToken, expiration: new Date(expiresAt) };
+  if (existingToken.expiration.getTime() - Date.now() > EXPIRE_WINDOW_MS) {
+    return existingToken;
+  }
+  if (Date.now() - lastRefreshAttemptTime.getTime() < 30 * 1000) {
+    validateTokenExpiry(existingToken);
+    return existingToken;
+  }
+  validateTokenKey("clientId", ssoToken.clientId, true);
+  validateTokenKey("clientSecret", ssoToken.clientSecret, true);
+  validateTokenKey("refreshToken", ssoToken.refreshToken, true);
+  try {
+    lastRefreshAttemptTime.setTime(Date.now());
+    const newSsoOidcToken = await getNewSsoOidcToken(ssoToken, ssoRegion, init, callerClientConfig);
+    validateTokenKey("accessToken", newSsoOidcToken.accessToken);
+    validateTokenKey("expiresIn", newSsoOidcToken.expiresIn);
+    const newTokenExpiration = new Date(Date.now() + newSsoOidcToken.expiresIn * 1000);
+    try {
+      await writeSSOTokenToFile(ssoSessionName, {
+        ...ssoToken,
+        accessToken: newSsoOidcToken.accessToken,
+        expiresAt: newTokenExpiration.toISOString(),
+        refreshToken: newSsoOidcToken.refreshToken
+      });
+    } catch (error) {}
+    return {
+      token: newSsoOidcToken.accessToken,
+      expiration: newTokenExpiration
+    };
+  } catch (error) {
+    validateTokenExpiry(existingToken);
+    return existingToken;
+  }
+};
+var init_fromSso = __esm(() => {
+  init_constants();
+  init_getNewSsoOidcToken();
+  init_validateTokenExpiry();
+  init_validateTokenKey();
+  init_writeSSOTokenToFile();
+  import_property_provider4 = __toESM(require_dist_cjs(), 1);
+  import_shared_ini_file_loader2 = __toESM(require_dist_cjs2(), 1);
+  lastRefreshAttemptTime = new Date(0);
+});
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/nodeProvider.js
+var import_property_provider5, nodeProvider = (init = {}) => import_property_provider5.memoize(import_property_provider5.chain(fromSso(init), async () => {
+  throw new import_property_provider5.TokenProviderError("Could not load token from any providers", false);
+}), (token) => token.expiration !== undefined && token.expiration.getTime() - Date.now() < 300000, (token) => token.expiration !== undefined);
+var init_nodeProvider = __esm(() => {
+  init_fromSso();
+  import_property_provider5 = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/fromStatic.js
+var init_fromStatic = () => {};
+
+// node_modules/.bun/@aws-sdk+token-providers@3.1020.0/node_modules/@aws-sdk/token-providers/dist-es/index.js
+var init_dist_es = __esm(() => {
+  init_fromEnvSigningName();
+  init_fromSso();
+  init_fromStatic();
+  init_nodeProvider();
+});
+
+export { fromEnvSigningName, fromSso, nodeProvider, init_dist_es };

package/dist/chunk-cpe70sxw.js

@@ -0,0 +1,79 @@
+// @bun
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-7wm1rjfm.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-vratq94g.js";
+import"./chunk-5hva0tsg.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-g0j0t6qk.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-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-x14dq3v1.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.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"./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 {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/vim/vim.ts
+var call = async () => {
+  const config = getGlobalConfig();
+  let currentMode = config.editorMode || "normal";
+  if (currentMode === "emacs") {
+    currentMode = "normal";
+  }
+  const newMode = currentMode === "normal" ? "vim" : "normal";
+  saveGlobalConfig((current) => ({
+    ...current,
+    editorMode: newMode
+  }));
+  logEvent("tengu_editor_mode_changed", {
+    mode: newMode,
+    source: "command"
+  });
+  return {
+    type: "text",
+    value: `Editor mode set to ${newMode}. ${newMode === "vim" ? "Use Escape key to toggle between INSERT and NORMAL modes." : "Using standard (readline) keyboard bindings."}`
+  };
+};
+var init_vim = __esm(() => {
+  init_analytics();
+  init_config();
+});
+init_vim();
+
+export {
+  call
+};

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 };

package/dist/chunk-cvge4pvp.js

@@ -0,0 +1,122 @@
+// @bun
+import {
+  init_analytics
+} from "./chunk-h0rbjg6x.js";
+import {
+  init_debug
+} from "./chunk-nxsh6de2.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/bash/bashParser.ts
+var READY, SPECIAL_VARS, DECL_KEYWORDS, SHELL_KEYWORDS, ARITH_RIGHT_ASSOC;
+var init_bashParser = __esm(() => {
+  READY = Promise.resolve();
+  SPECIAL_VARS = new Set(["?", "$", "@", "*", "#", "-", "!", "_"]);
+  DECL_KEYWORDS = new Set([
+    "export",
+    "declare",
+    "typeset",
+    "readonly",
+    "local"
+  ]);
+  SHELL_KEYWORDS = new Set([
+    "if",
+    "then",
+    "elif",
+    "else",
+    "fi",
+    "while",
+    "until",
+    "for",
+    "in",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "function",
+    "select"
+  ]);
+  ARITH_RIGHT_ASSOC = new Set([
+    "=",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "<<=",
+    ">>=",
+    "&=",
+    "^=",
+    "|=",
+    "**"
+  ]);
+});
+
+// src/utils/bash/parser.ts
+async function ensureInitialized() {
+  if (false) {}
+}
+async function parseCommand(command) {
+  if (!command || command.length > MAX_COMMAND_LENGTH)
+    return null;
+  if (false) {}
+  return null;
+}
+async function parseCommandRaw(command) {
+  if (!command || command.length > MAX_COMMAND_LENGTH)
+    return null;
+  if (false) {}
+  return null;
+}
+function extractCommandArguments(commandNode) {
+  if (commandNode.type === "declaration_command") {
+    const firstChild = commandNode.children[0];
+    return firstChild && DECLARATION_COMMANDS.has(firstChild.text) ? [firstChild.text] : [];
+  }
+  const args = [];
+  let foundCommandName = false;
+  for (const child of commandNode.children) {
+    if (child.type === "variable_assignment")
+      continue;
+    if (child.type === "command_name" || !foundCommandName && child.type === "word") {
+      foundCommandName = true;
+      args.push(child.text);
+      continue;
+    }
+    if (ARGUMENT_TYPES.has(child.type)) {
+      args.push(stripQuotes(child.text));
+    } else if (SUBSTITUTION_TYPES.has(child.type)) {
+      break;
+    }
+  }
+  return args;
+}
+function stripQuotes(text) {
+  return text.length >= 2 && (text[0] === '"' && text.at(-1) === '"' || text[0] === "'" && text.at(-1) === "'") ? text.slice(1, -1) : text;
+}
+var MAX_COMMAND_LENGTH = 1e4, DECLARATION_COMMANDS, ARGUMENT_TYPES, SUBSTITUTION_TYPES, COMMAND_TYPES, PARSE_ABORTED;
+var init_parser = __esm(() => {
+  init_analytics();
+  init_debug();
+  init_bashParser();
+  DECLARATION_COMMANDS = new Set([
+    "export",
+    "declare",
+    "typeset",
+    "readonly",
+    "local",
+    "unset",
+    "unsetenv"
+  ]);
+  ARGUMENT_TYPES = new Set(["word", "string", "raw_string", "number"]);
+  SUBSTITUTION_TYPES = new Set([
+    "command_substitution",
+    "process_substitution"
+  ]);
+  COMMAND_TYPES = new Set(["command", "declaration_command"]);
+  PARSE_ABORTED = Symbol("parse-aborted");
+});
+
+export { SHELL_KEYWORDS, init_bashParser, ensureInitialized, parseCommand, PARSE_ABORTED, parseCommandRaw, extractCommandArguments, init_parser };