@zyycn/claudex 1.0.3-fork.1453470

package/dist/chunk-tj6kpqkn.js

@@ -0,0 +1,338 @@
+// @bun
+import {
+  BROWSER_TOOLS,
+  init_src
+} from "./chunk-gyj242zr.js";
+import {
+  getChromeSystemPrompt,
+  init_prompt
+} from "./chunk-tggpkxkz.js";
+import {
+  CLAUDE_IN_CHROME_MCP_SERVER_NAME,
+  getAllBrowserDataPaths,
+  getAllNativeMessagingHostsDirs,
+  getAllWindowsRegistryKeys,
+  init_common,
+  openInChrome
+} from "./chunk-j5hc27hv.js";
+import {
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getGlobalConfig,
+  init_config1 as init_config,
+  init_growthbook,
+  saveGlobalConfig
+} from "./chunk-3tqnjgfx.js";
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-nj17bhkh.js";
+import {
+  init_bundledMode,
+  isInBundledMode
+} from "./chunk-wn2268qd.js";
+import {
+  execFileNoThrowWithCwd,
+  init_execFileNoThrow
+} from "./chunk-gzzfhtdv.js";
+import {
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  isFsInaccessible,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils,
+  isEnvDefinedFalsy,
+  isEnvTruthy
+} from "./chunk-raqgs410.js";
+import {
+  getIsInteractive,
+  getIsNonInteractiveSession,
+  getSessionBypassPermissionsMode,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/claudeInChrome/setupPortable.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+function getExtensionIds() {
+  return process.env.USER_TYPE === "ant" ? [PROD_EXTENSION_ID, DEV_EXTENSION_ID, ANT_EXTENSION_ID] : [PROD_EXTENSION_ID];
+}
+async function detectExtensionInstallationPortable(browserPaths, log) {
+  if (browserPaths.length === 0) {
+    log?.(`[Claude in Chrome] No browser paths to check`);
+    return { isInstalled: false, browser: null };
+  }
+  const extensionIds = getExtensionIds();
+  for (const { browser, path: browserBasePath } of browserPaths) {
+    let browserProfileEntries = [];
+    try {
+      browserProfileEntries = await readdir(browserBasePath, {
+        withFileTypes: true
+      });
+    } catch (e) {
+      if (isFsInaccessible(e))
+        continue;
+      throw e;
+    }
+    const profileDirs = browserProfileEntries.filter((entry) => entry.isDirectory()).filter((entry) => entry.name === "Default" || entry.name.startsWith("Profile ")).map((entry) => entry.name);
+    if (profileDirs.length > 0) {
+      log?.(`[Claude in Chrome] Found ${browser} profiles: ${profileDirs.join(", ")}`);
+    }
+    for (const profile of profileDirs) {
+      for (const extensionId of extensionIds) {
+        const extensionPath = join(browserBasePath, profile, "Extensions", extensionId);
+        try {
+          await readdir(extensionPath);
+          log?.(`[Claude in Chrome] Extension ${extensionId} found in ${browser} ${profile}`);
+          return { isInstalled: true, browser };
+        } catch {}
+      }
+    }
+  }
+  log?.(`[Claude in Chrome] Extension not found in any browser`);
+  return { isInstalled: false, browser: null };
+}
+async function isChromeExtensionInstalledPortable(browserPaths, log) {
+  const result = await detectExtensionInstallationPortable(browserPaths, log);
+  return result.isInstalled;
+}
+var PROD_EXTENSION_ID = "fcoeoabgfenejglbffodgkkbkcdhcgfn", DEV_EXTENSION_ID = "dihbgbndebgnbjfmelmegjepbnkhlgni", ANT_EXTENSION_ID = "dngcpimnedloihjnnfngkgjoidhnaolf";
+var init_setupPortable = __esm(() => {
+  init_errors();
+});
+
+// src/utils/claudeInChrome/setup.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+function shouldEnableClaudeInChrome(chromeFlag) {
+  if (getIsNonInteractiveSession() && chromeFlag !== true) {
+    return false;
+  }
+  if (chromeFlag === true) {
+    return true;
+  }
+  if (chromeFlag === false) {
+    return false;
+  }
+  if (isEnvTruthy(process.env.CLAUDE_CODE_ENABLE_CFC)) {
+    return true;
+  }
+  if (isEnvDefinedFalsy(process.env.CLAUDE_CODE_ENABLE_CFC)) {
+    return false;
+  }
+  const config = getGlobalConfig();
+  if (config.claudeInChromeDefaultEnabled !== undefined) {
+    return config.claudeInChromeDefaultEnabled;
+  }
+  return false;
+}
+function shouldAutoEnableClaudeInChrome() {
+  if (shouldAutoEnable !== undefined) {
+    return shouldAutoEnable;
+  }
+  shouldAutoEnable = getIsInteractive() && isChromeExtensionInstalled_CACHED_MAY_BE_STALE() && (process.env.USER_TYPE === "ant" || getFeatureValue_CACHED_MAY_BE_STALE("tengu_chrome_auto_enable", false));
+  return shouldAutoEnable;
+}
+function setupClaudeInChrome() {
+  const isNativeBuild = isInBundledMode();
+  const allowedTools = BROWSER_TOOLS.map((tool) => `mcp__claude-in-chrome__${tool.name}`);
+  const env = {};
+  if (getSessionBypassPermissionsMode()) {
+    env.CLAUDE_CHROME_PERMISSION_MODE = "skip_all_permission_checks";
+  }
+  const hasEnv = Object.keys(env).length > 0;
+  if (isNativeBuild) {
+    const execCommand = `"${process.execPath}" --chrome-native-host`;
+    createWrapperScript(execCommand).then((manifestBinaryPath) => installChromeNativeHostManifest(manifestBinaryPath)).catch((e) => logForDebugging(`[Claude in Chrome] Failed to install native host: ${e}`, { level: "error" }));
+    return {
+      mcpConfig: {
+        [CLAUDE_IN_CHROME_MCP_SERVER_NAME]: {
+          type: "stdio",
+          command: process.execPath,
+          args: ["--claude-in-chrome-mcp"],
+          scope: "dynamic",
+          ...hasEnv && { env }
+        }
+      },
+      allowedTools,
+      systemPrompt: getChromeSystemPrompt()
+    };
+  } else {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = join2(__filename2, "..");
+    const cliPath = join2(__dirname2, "cli.js");
+    createWrapperScript(`"${process.execPath}" "${cliPath}" --chrome-native-host`).then((manifestBinaryPath) => installChromeNativeHostManifest(manifestBinaryPath)).catch((e) => logForDebugging(`[Claude in Chrome] Failed to install native host: ${e}`, { level: "error" }));
+    const mcpConfig = {
+      [CLAUDE_IN_CHROME_MCP_SERVER_NAME]: {
+        type: "stdio",
+        command: process.execPath,
+        args: [`${cliPath}`, "--claude-in-chrome-mcp"],
+        scope: "dynamic",
+        ...hasEnv && { env }
+      }
+    };
+    return {
+      mcpConfig,
+      allowedTools,
+      systemPrompt: getChromeSystemPrompt()
+    };
+  }
+}
+function getNativeMessagingHostsDirs() {
+  const platform = getPlatform();
+  if (platform === "windows") {
+    const home = homedir();
+    const appData = process.env.APPDATA || join2(home, "AppData", "Local");
+    return [join2(appData, "Claude Code", "ChromeNativeHost")];
+  }
+  return getAllNativeMessagingHostsDirs().map(({ path }) => path);
+}
+async function installChromeNativeHostManifest(manifestBinaryPath) {
+  const manifestDirs = getNativeMessagingHostsDirs();
+  if (manifestDirs.length === 0) {
+    throw Error("Claude in Chrome Native Host not supported on this platform");
+  }
+  const manifest = {
+    name: NATIVE_HOST_IDENTIFIER,
+    description: "Claude Code Browser Extension Native Host",
+    path: manifestBinaryPath,
+    type: "stdio",
+    allowed_origins: [
+      `chrome-extension://fcoeoabgfenejglbffodgkkbkcdhcgfn/`,
+      ...process.env.USER_TYPE === "ant" ? [
+        "chrome-extension://dihbgbndebgnbjfmelmegjepbnkhlgni/",
+        "chrome-extension://dngcpimnedloihjnnfngkgjoidhnaolf/"
+      ] : []
+    ]
+  };
+  const manifestContent = jsonStringify(manifest, null, 2);
+  let anyManifestUpdated = false;
+  for (const manifestDir of manifestDirs) {
+    const manifestPath = join2(manifestDir, NATIVE_HOST_MANIFEST_NAME);
+    const existingContent = await readFile(manifestPath, "utf-8").catch(() => null);
+    if (existingContent === manifestContent) {
+      continue;
+    }
+    try {
+      await mkdir(manifestDir, { recursive: true });
+      await writeFile(manifestPath, manifestContent);
+      logForDebugging(`[Claude in Chrome] Installed native host manifest at: ${manifestPath}`);
+      anyManifestUpdated = true;
+    } catch (error) {
+      logForDebugging(`[Claude in Chrome] Failed to install manifest at ${manifestPath}: ${error}`);
+    }
+  }
+  if (getPlatform() === "windows") {
+    const manifestPath = join2(manifestDirs[0], NATIVE_HOST_MANIFEST_NAME);
+    registerWindowsNativeHosts(manifestPath);
+  }
+  if (anyManifestUpdated) {
+    isChromeExtensionInstalled().then((isInstalled) => {
+      if (isInstalled) {
+        logForDebugging(`[Claude in Chrome] First-time install detected, opening reconnect page in browser`);
+        openInChrome(CHROME_EXTENSION_RECONNECT_URL);
+      } else {
+        logForDebugging(`[Claude in Chrome] First-time install detected, but extension not installed, skipping reconnect`);
+      }
+    });
+  }
+}
+function registerWindowsNativeHosts(manifestPath) {
+  const registryKeys = getAllWindowsRegistryKeys();
+  for (const { browser, key } of registryKeys) {
+    const fullKey = `${key}\\${NATIVE_HOST_IDENTIFIER}`;
+    execFileNoThrowWithCwd("reg", [
+      "add",
+      fullKey,
+      "/ve",
+      "/t",
+      "REG_SZ",
+      "/d",
+      manifestPath,
+      "/f"
+    ]).then((result) => {
+      if (result.code === 0) {
+        logForDebugging(`[Claude in Chrome] Registered native host for ${browser} in Windows registry: ${fullKey}`);
+      } else {
+        logForDebugging(`[Claude in Chrome] Failed to register native host for ${browser} in Windows registry: ${result.stderr}`);
+      }
+    });
+  }
+}
+async function createWrapperScript(command) {
+  const platform = getPlatform();
+  const chromeDir = join2(getClaudeConfigHomeDir(), "chrome");
+  const wrapperPath = platform === "windows" ? join2(chromeDir, "chrome-native-host.bat") : join2(chromeDir, "chrome-native-host");
+  const scriptContent = platform === "windows" ? `@echo off
+REM Chrome native host wrapper script
+REM Generated by Claude Code - do not edit manually
+${command}
+` : `#!/bin/sh
+# Chrome native host wrapper script
+# Generated by Claude Code - do not edit manually
+exec ${command}
+`;
+  const existingContent = await readFile(wrapperPath, "utf-8").catch(() => null);
+  if (existingContent === scriptContent) {
+    return wrapperPath;
+  }
+  await mkdir(chromeDir, { recursive: true });
+  await writeFile(wrapperPath, scriptContent);
+  if (platform !== "windows") {
+    await chmod(wrapperPath, 493);
+  }
+  logForDebugging(`[Claude in Chrome] Created Chrome native host wrapper script: ${wrapperPath}`);
+  return wrapperPath;
+}
+function isChromeExtensionInstalled_CACHED_MAY_BE_STALE() {
+  isChromeExtensionInstalled().then((isInstalled) => {
+    if (!isInstalled) {
+      return;
+    }
+    const config = getGlobalConfig();
+    if (config.cachedChromeExtensionInstalled !== isInstalled) {
+      saveGlobalConfig((prev) => ({
+        ...prev,
+        cachedChromeExtensionInstalled: isInstalled
+      }));
+    }
+  });
+  const cached = getGlobalConfig().cachedChromeExtensionInstalled;
+  return cached ?? false;
+}
+async function isChromeExtensionInstalled() {
+  const browserPaths = getAllBrowserDataPaths();
+  if (browserPaths.length === 0) {
+    logForDebugging(`[Claude in Chrome] Unsupported platform for extension detection: ${getPlatform()}`);
+    return false;
+  }
+  return isChromeExtensionInstalledPortable(browserPaths, logForDebugging);
+}
+var CHROME_EXTENSION_RECONNECT_URL = "https://clau.de/chrome/reconnect", NATIVE_HOST_IDENTIFIER = "com.anthropic.claude_code_browser_extension", NATIVE_HOST_MANIFEST_NAME, shouldAutoEnable = undefined;
+var init_setup = __esm(() => {
+  init_src();
+  init_state();
+  init_growthbook();
+  init_bundledMode();
+  init_config();
+  init_debug();
+  init_envUtils();
+  init_execFileNoThrow();
+  init_platform();
+  init_slowOperations();
+  init_common();
+  init_prompt();
+  init_setupPortable();
+  NATIVE_HOST_MANIFEST_NAME = `${NATIVE_HOST_IDENTIFIER}.json`;
+});
+
+export { shouldEnableClaudeInChrome, shouldAutoEnableClaudeInChrome, setupClaudeInChrome, isChromeExtensionInstalled, init_setup };

package/dist/chunk-tjk56vh8.js

@@ -0,0 +1,81 @@
+// @bun
+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+credential-provider-web-identity@3.972.27/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromWebToken.js
+var fromWebToken = (init) => async (awsIdentityProperties) => {
+  init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
+  const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
+  let { roleAssumerWithWebIdentity } = init;
+  if (!roleAssumerWithWebIdentity) {
+    const { getDefaultRoleAssumerWithWebIdentity } = await import("./chunk-q7bxdsfd.js").then((m)=>__toESM(m.default,1));
+    roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({
+      ...init.clientConfig,
+      credentialProviderLogger: init.logger,
+      parentClientConfig: {
+        ...awsIdentityProperties?.callerClientConfig,
+        ...init.parentClientConfig
+      }
+    }, init.clientPlugins);
+  }
+  return roleAssumerWithWebIdentity({
+    RoleArn: roleArn,
+    RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,
+    WebIdentityToken: webIdentityToken,
+    ProviderId: providerId,
+    PolicyArns: policyArns,
+    Policy: policy,
+    DurationSeconds: durationSeconds
+  });
+};
+var init_fromWebToken = () => {};
+
+// node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.27/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
+import { readFileSync } from "fs";
+var import_client, import_property_provider, import_shared_ini_file_loader, ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE", ENV_ROLE_ARN = "AWS_ROLE_ARN", ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME", fromTokenFile = (init = {}) => async (awsIdentityProperties) => {
+  init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
+  const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
+  const roleArn = init?.roleArn ?? process.env[ENV_ROLE_ARN];
+  const roleSessionName = init?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME];
+  if (!webIdentityTokenFile || !roleArn) {
+    throw new import_property_provider.CredentialsProviderError("Web identity configuration not specified", {
+      logger: init.logger
+    });
+  }
+  const credentials = await fromWebToken({
+    ...init,
+    webIdentityToken: import_shared_ini_file_loader.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync(webIdentityTokenFile, { encoding: "ascii" }),
+    roleArn,
+    roleSessionName
+  })(awsIdentityProperties);
+  if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) {
+    import_client.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
+  }
+  return credentials;
+};
+var init_fromTokenFile = __esm(() => {
+  init_fromWebToken();
+  import_client = __toESM(require_client(), 1);
+  import_property_provider = __toESM(require_dist_cjs(), 1);
+  import_shared_ini_file_loader = __toESM(require_dist_cjs2(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.27/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/index.js
+var init_dist_es = __esm(() => {
+  init_fromTokenFile();
+  init_fromWebToken();
+});
+
+export { fromWebToken, fromTokenFile, init_dist_es };

package/dist/chunk-tn9vdsk8.js

@@ -0,0 +1,42 @@
+// @bun
+import {
+  require_compiler_runtime
+} from "./chunk-zp37prdd.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/context/fpsMetrics.tsx
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+var import_react = __toESM(require_react(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+var FpsMetricsContext = import_react.createContext(undefined);
+function FpsMetricsProvider(t0) {
+  const $ = import_compiler_runtime.c(3);
+  const {
+    getFpsMetrics,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== children || $[1] !== getFpsMetrics) {
+    t1 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(FpsMetricsContext.Provider, {
+      value: getFpsMetrics,
+      children
+    }, undefined, false, undefined, this);
+    $[0] = children;
+    $[1] = getFpsMetrics;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+function useFpsMetrics() {
+  return import_react.useContext(FpsMetricsContext);
+}
+
+export { FpsMetricsProvider, useFpsMetrics };

package/dist/chunk-tnkpg5zy.js

@@ -0,0 +1,96 @@
+// @bun
+import {
+  getSettingsWithAllErrors,
+  init_allErrors,
+  init_notifications,
+  init_useSettingsChange,
+  useNotifications,
+  useSettingsChange
+} from "./chunk-730qrdey.js";
+import {
+  require_compiler_runtime
+} from "./chunk-zp37prdd.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  getIsRemoteMode,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/hooks/notifs/useSettingsErrors.tsx
+function useSettingsErrors() {
+  const $ = import_compiler_runtime.c(6);
+  const {
+    addNotification,
+    removeNotification
+  } = useNotifications();
+  const [errors_0, setErrors] = import_react.useState(_temp);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = () => {
+      const {
+        errors: errors_1
+      } = getSettingsWithAllErrors();
+      setErrors(errors_1);
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const handleSettingsChange = t0;
+  useSettingsChange(handleSettingsChange);
+  let t1;
+  let t2;
+  if ($[1] !== addNotification || $[2] !== errors_0 || $[3] !== removeNotification) {
+    t1 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (errors_0.length > 0) {
+        const message = `Found ${errors_0.length} settings ${errors_0.length === 1 ? "issue" : "issues"} \xB7 /doctor for details`;
+        addNotification({
+          key: SETTINGS_ERRORS_NOTIFICATION_KEY,
+          text: message,
+          color: "warning",
+          priority: "high",
+          timeoutMs: 60000
+        });
+      } else {
+        removeNotification(SETTINGS_ERRORS_NOTIFICATION_KEY);
+      }
+    };
+    t2 = [errors_0, addNotification, removeNotification];
+    $[1] = addNotification;
+    $[2] = errors_0;
+    $[3] = removeNotification;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t1 = $[4];
+    t2 = $[5];
+  }
+  import_react.useEffect(t1, t2);
+  return errors_0;
+}
+function _temp() {
+  const {
+    errors
+  } = getSettingsWithAllErrors();
+  return errors;
+}
+var import_compiler_runtime, import_react, SETTINGS_ERRORS_NOTIFICATION_KEY = "settings-errors";
+var init_useSettingsErrors = __esm(() => {
+  init_notifications();
+  init_state();
+  init_allErrors();
+  init_useSettingsChange();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  import_react = __toESM(require_react(), 1);
+});
+
+export { useSettingsErrors, init_useSettingsErrors };

package/dist/chunk-tp1jevns.js

@@ -0,0 +1,88 @@
+// @bun
+import {
+  ClaudeMdExternalIncludesDialog,
+  init_ClaudeMdExternalIncludesDialog
+} from "./chunk-kz5tvd47.js";
+import"./chunk-730qrdey.js";
+import"./chunk-cfmxfyg6.js";
+import"./chunk-vwtd8nde.js";
+import"./chunk-nsw7n8c5.js";
+import"./chunk-v7n7nnwc.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-tggpkxkz.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-xfxyj6qk.js";
+import"./chunk-n8326eqb.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-ps540063.js";
+import"./chunk-fz0qs5hv.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-re8evv5h.js";
+import"./chunk-g3jde8ef.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-6p1yy212.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-gdr19kp1.js";
+import"./chunk-zp37prdd.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-ya2a18ws.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-14as9yqj.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-vn4hnzzj.js";
+import"./chunk-3tqnjgfx.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-res15ktd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.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"./chunk-qp2qdcda.js";
+init_ClaudeMdExternalIncludesDialog();
+
+export {
+  ClaudeMdExternalIncludesDialog
+};