@xelauvas/xela-cli 0.1.0

package/src/components/PromptInput/PromptInputFooterLeftSide.tsx

@@ -0,0 +1,517 @@
+import { c as _c } from "react/compiler-runtime";
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { feature } from 'bun:bundle';
+// Dead code elimination: conditional import for COORDINATOR_MODE
+/* eslint-disable @typescript-eslint/no-require-imports */
+const coordinatorModule = feature('COORDINATOR_MODE') ? require('../../coordinator/coordinatorMode.js') as typeof import('../../coordinator/coordinatorMode.js') : undefined;
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { Box, Text, Link } from '../../ink.js';
+import * as React from 'react';
+import figures from 'figures';
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
+import type { VimMode, PromptInputMode } from '../../types/textInputTypes.js';
+import type { ToolPermissionContext } from '../../Tool.js';
+import { isVimModeEnabled } from './utils.js';
+import { useShortcutDisplay } from '../../keybindings/useShortcutDisplay.js';
+import { isDefaultMode, permissionModeSymbol, permissionModeTitle, getModeColor } from '../../utils/permissions/PermissionMode.js';
+import { BackgroundTaskStatus } from '../tasks/BackgroundTaskStatus.js';
+import { isBackgroundTask } from '../../tasks/types.js';
+import { isPanelAgentTask } from '../../tasks/LocalAgentTask/LocalAgentTask.js';
+import { getVisibleAgentTasks } from '../CoordinatorAgentStatus.js';
+import { count } from '../../utils/array.js';
+import { shouldHideTasksFooter } from '../tasks/taskStatusUtils.js';
+import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js';
+import { TeamStatus } from '../teams/TeamStatus.js';
+import { isInProcessEnabled } from '../../utils/swarm/backends/registry.js';
+import { useAppState, useAppStateStore } from 'src/state/AppState.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import HistorySearchInput from './HistorySearchInput.js';
+import { usePrStatus } from '../../hooks/usePrStatus.js';
+import { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js';
+import { Byline } from '../design-system/Byline.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import { useTasksV2 } from '../../hooks/useTasksV2.js';
+import { formatDuration } from '../../utils/format.js';
+import { VoiceWarmupHint } from './VoiceIndicator.js';
+import { useVoiceEnabled } from '../../hooks/useVoiceEnabled.js';
+import { useVoiceState } from '../../context/voice.js';
+import { isFullscreenEnvEnabled } from '../../utils/fullscreen.js';
+import { isXtermJs } from '../../ink/terminal.js';
+import { useHasSelection, useSelection } from '../../ink/hooks/use-selection.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { getPlatform } from '../../utils/platform.js';
+import { PrBadge } from '../PrBadge.js';
+
+// Dead code elimination: conditional import for proactive mode
+/* eslint-disable @typescript-eslint/no-require-imports */
+const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? require('../../proactive/index.js') : null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+const NO_OP_SUBSCRIBE = (_cb: () => void) => () => {};
+const NULL = () => null;
+const MAX_VOICE_HINT_SHOWS = 3;
+type Props = {
+  exitMessage: {
+    show: boolean;
+    key?: string;
+  };
+  vimMode: VimMode | undefined;
+  mode: PromptInputMode;
+  toolPermissionContext: ToolPermissionContext;
+  suppressHint: boolean;
+  isLoading: boolean;
+  showMemoryTypeSelector?: boolean;
+  tasksSelected: boolean;
+  teamsSelected: boolean;
+  tmuxSelected: boolean;
+  teammateFooterIndex?: number;
+  isPasting?: boolean;
+  isSearching: boolean;
+  historyQuery: string;
+  setHistoryQuery: (query: string) => void;
+  historyFailedMatch: boolean;
+  onOpenTasksDialog?: (taskId?: string) => void;
+};
+function ProactiveCountdown() {
+  const $ = _c(7);
+  const nextTickAt = useSyncExternalStore(proactiveModule?.subscribeToProactiveChanges ?? NO_OP_SUBSCRIBE, proactiveModule?.getNextTickAt ?? NULL, NULL);
+  const [remainingSeconds, setRemainingSeconds] = useState(null);
+  let t0;
+  let t1;
+  if ($[0] !== nextTickAt) {
+    t0 = () => {
+      if (nextTickAt === null) {
+        setRemainingSeconds(null);
+        return;
+      }
+      const update = function update() {
+        const remaining = Math.max(0, Math.ceil((nextTickAt - Date.now()) / 1000));
+        setRemainingSeconds(remaining);
+      };
+      update();
+      const interval = setInterval(update, 1000);
+      return () => clearInterval(interval);
+    };
+    t1 = [nextTickAt];
+    $[0] = nextTickAt;
+    $[1] = t0;
+    $[2] = t1;
+  } else {
+    t0 = $[1];
+    t1 = $[2];
+  }
+  useEffect(t0, t1);
+  if (remainingSeconds === null) {
+    return null;
+  }
+  const t2 = remainingSeconds * 1000;
+  let t3;
+  if ($[3] !== t2) {
+    t3 = formatDuration(t2, {
+      mostSignificantOnly: true
+    });
+    $[3] = t2;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== t3) {
+    t4 = <Text dimColor={true}>waiting{" "}{t3}</Text>;
+    $[5] = t3;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  return t4;
+}
+export function PromptInputFooterLeftSide(t0) {
+  const $ = _c(27);
+  const {
+    exitMessage,
+    vimMode,
+    mode,
+    toolPermissionContext,
+    suppressHint,
+    isLoading,
+    tasksSelected,
+    teamsSelected,
+    tmuxSelected,
+    teammateFooterIndex,
+    isPasting,
+    isSearching,
+    historyQuery,
+    setHistoryQuery,
+    historyFailedMatch,
+    onOpenTasksDialog
+  } = t0;
+  if (exitMessage.show) {
+    let t1;
+    if ($[0] !== exitMessage.key) {
+      t1 = <Text dimColor={true} key="exit-message">Press {exitMessage.key} again to exit</Text>;
+      $[0] = exitMessage.key;
+      $[1] = t1;
+    } else {
+      t1 = $[1];
+    }
+    return t1;
+  }
+  if (isPasting) {
+    let t1;
+    if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <Text dimColor={true} key="pasting-message">Pasting text…</Text>;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[3] !== isSearching || $[4] !== vimMode) {
+    t1 = isVimModeEnabled() && vimMode === "INSERT" && !isSearching;
+    $[3] = isSearching;
+    $[4] = vimMode;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const showVim = t1;
+  let t2;
+  if ($[6] !== historyFailedMatch || $[7] !== historyQuery || $[8] !== isSearching || $[9] !== setHistoryQuery) {
+    t2 = isSearching && <HistorySearchInput value={historyQuery} onChange={setHistoryQuery} historyFailedMatch={historyFailedMatch} />;
+    $[6] = historyFailedMatch;
+    $[7] = historyQuery;
+    $[8] = isSearching;
+    $[9] = setHistoryQuery;
+    $[10] = t2;
+  } else {
+    t2 = $[10];
+  }
+  let t3;
+  if ($[11] !== showVim) {
+    t3 = showVim ? <Text dimColor={true} key="vim-insert">-- INSERT --</Text> : null;
+    $[11] = showVim;
+    $[12] = t3;
+  } else {
+    t3 = $[12];
+  }
+  const t4 = !suppressHint && !showVim;
+  let t5;
+  if ($[13] !== isLoading || $[14] !== mode || $[15] !== onOpenTasksDialog || $[16] !== t4 || $[17] !== tasksSelected || $[18] !== teammateFooterIndex || $[19] !== teamsSelected || $[20] !== tmuxSelected || $[21] !== toolPermissionContext) {
+    t5 = <ModeIndicator mode={mode} toolPermissionContext={toolPermissionContext} showHint={t4} isLoading={isLoading} tasksSelected={tasksSelected} teamsSelected={teamsSelected} teammateFooterIndex={teammateFooterIndex} tmuxSelected={tmuxSelected} onOpenTasksDialog={onOpenTasksDialog} />;
+    $[13] = isLoading;
+    $[14] = mode;
+    $[15] = onOpenTasksDialog;
+    $[16] = t4;
+    $[17] = tasksSelected;
+    $[18] = teammateFooterIndex;
+    $[19] = teamsSelected;
+    $[20] = tmuxSelected;
+    $[21] = toolPermissionContext;
+    $[22] = t5;
+  } else {
+    t5 = $[22];
+  }
+  let t6;
+  if ($[23] !== t2 || $[24] !== t3 || $[25] !== t5) {
+    t6 = <Box justifyContent="flex-start" gap={1}>{t2}{t3}{t5}</Box>;
+    $[23] = t2;
+    $[24] = t3;
+    $[25] = t5;
+    $[26] = t6;
+  } else {
+    t6 = $[26];
+  }
+  return t6;
+}
+type ModeIndicatorProps = {
+  mode: PromptInputMode;
+  toolPermissionContext: ToolPermissionContext;
+  showHint: boolean;
+  isLoading: boolean;
+  tasksSelected: boolean;
+  teamsSelected: boolean;
+  tmuxSelected: boolean;
+  teammateFooterIndex?: number;
+  onOpenTasksDialog?: (taskId?: string) => void;
+};
+function ModeIndicator({
+  mode,
+  toolPermissionContext,
+  showHint,
+  isLoading,
+  tasksSelected,
+  teamsSelected,
+  tmuxSelected,
+  teammateFooterIndex,
+  onOpenTasksDialog
+}: ModeIndicatorProps): React.ReactNode {
+  const {
+    columns
+  } = useTerminalSize();
+  const modeCycleShortcut = useShortcutDisplay('chat:cycleMode', 'Chat', 'shift+tab');
+  const tasks = useAppState(s => s.tasks);
+  const teamContext = useAppState(s_0 => s_0.teamContext);
+  // Set once in initialState (main.tsx --remote mode) and never mutated — lazy
+  // init captures the immutable value without a subscription.
+  const store = useAppStateStore();
+  const [remoteSessionUrl] = useState(() => store.getState().remoteSessionUrl);
+  const viewSelectionMode = useAppState(s_1 => s_1.viewSelectionMode);
+  const viewingAgentTaskId = useAppState(s_2 => s_2.viewingAgentTaskId);
+  const expandedView = useAppState(s_3 => s_3.expandedView);
+  const showSpinnerTree = expandedView === 'teammates';
+  const prStatus = usePrStatus(isLoading, isPrStatusEnabled());
+  const hasTmuxSession = useAppState(s_4 => "external" === 'ant' && s_4.tungstenActiveSession !== undefined);
+  const nextTickAt = useSyncExternalStore(proactiveModule?.subscribeToProactiveChanges ?? NO_OP_SUBSCRIBE, proactiveModule?.getNextTickAt ?? NULL, NULL);
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false;
+  const voiceState = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useVoiceState(s_5 => s_5.voiceState) : 'idle' as const;
+  const voiceWarmingUp = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useVoiceState(s_6 => s_6.voiceWarmingUp) : false;
+  const hasSelection = useHasSelection();
+  const selGetState = useSelection().getState;
+  const hasNextTick = nextTickAt !== null;
+  const isCoordinator = feature('COORDINATOR_MODE') ? coordinatorModule?.isCoordinatorMode() === true : false;
+  const runningTaskCount = useMemo(() => count(Object.values(tasks), t => isBackgroundTask(t) && !("external" === 'ant' && isPanelAgentTask(t))), [tasks]);
+  const tasksV2 = useTasksV2();
+  const hasTaskItems = tasksV2 !== undefined && tasksV2.length > 0;
+  const escShortcut = useShortcutDisplay('chat:cancel', 'Chat', 'esc').toLowerCase();
+  const todosShortcut = useShortcutDisplay('app:toggleTodos', 'Global', 'ctrl+t');
+  const killAgentsShortcut = useShortcutDisplay('chat:killAgents', 'Chat', 'ctrl+x ctrl+k');
+  const voiceKeyShortcut = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useShortcutDisplay('voice:pushToTalk', 'Chat', 'Space') : '';
+  // Captured at mount so the hint doesn't flicker mid-session if another
+  // CC instance increments the counter. Incremented once via useEffect the
+  // first time voice is enabled in this session — approximates "hint was
+  // shown" without tracking the exact render-time condition (which depends
+  // on parts/hintParts computed after the early-return hooks boundary).
+  const [voiceHintUnderCap] = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useState(() => (getGlobalConfig().voiceFooterHintSeenCount ?? 0) < MAX_VOICE_HINT_SHOWS) : [false];
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  const voiceHintIncrementedRef = feature('VOICE_MODE') ? useRef(false) : null;
+  useEffect(() => {
+    if (feature('VOICE_MODE')) {
+      if (!voiceEnabled || !voiceHintUnderCap) return;
+      if (voiceHintIncrementedRef?.current) return;
+      if (voiceHintIncrementedRef) voiceHintIncrementedRef.current = true;
+      const newCount = (getGlobalConfig().voiceFooterHintSeenCount ?? 0) + 1;
+      saveGlobalConfig(prev => {
+        if ((prev.voiceFooterHintSeenCount ?? 0) >= newCount) return prev;
+        return {
+          ...prev,
+          voiceFooterHintSeenCount: newCount
+        };
+      });
+    }
+  }, [voiceEnabled, voiceHintUnderCap]);
+  const isKillAgentsConfirmShowing = useAppState(s_7 => s_7.notifications.current?.key === 'kill-agents-confirm');
+
+  // Derive team info from teamContext (no filesystem I/O needed)
+  // Match the same logic as TeamStatus to avoid trailing separator
+  // In-process mode uses Shift+Down/Up navigation, not footer teams menu
+  const hasTeams = isAgentSwarmsEnabled() && !isInProcessEnabled() && teamContext !== undefined && count(Object.values(teamContext.teammates), t_0 => t_0.name !== 'team-lead') > 0;
+  if (mode === 'bash') {
+    return <Text color="bashBorder">! for bash mode</Text>;
+  }
+  const currentMode = toolPermissionContext?.mode;
+  const hasActiveMode = !isDefaultMode(currentMode);
+  const viewedTask = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined;
+  const isViewingTeammate = viewSelectionMode === 'viewing-agent' && viewedTask?.type === 'in_process_teammate';
+  const isViewingCompletedTeammate = isViewingTeammate && viewedTask != null && viewedTask.status !== 'running';
+  const hasBackgroundTasks = runningTaskCount > 0 || isViewingTeammate;
+
+  // Count primary items (permission mode or coordinator mode, background tasks, and teams)
+  const primaryItemCount = (isCoordinator || hasActiveMode ? 1 : 0) + (hasBackgroundTasks ? 1 : 0) + (hasTeams ? 1 : 0);
+
+  // PR indicator is short (~10 chars) — unlike the old diff indicator the
+  // >=100 threshold was tuned for. Now that auto mode is effectively the
+  // baseline, primaryItemCount is ≥1 for most sessions; keep the threshold
+  // low enough to show PR status on standard 80-col terminals.
+  const shouldShowPrStatus = isPrStatusEnabled() && prStatus.number !== null && prStatus.reviewState !== null && prStatus.url !== null && primaryItemCount < 2 && (primaryItemCount === 0 || columns >= 80);
+
+  // Hide the shift+tab hint when there are 2 primary items
+  const shouldShowModeHint = primaryItemCount < 2;
+
+  // Check if we have in-process teammates (showing pills)
+  // In spinner-tree mode, pills are disabled - teammates appear in the spinner tree instead
+  const hasInProcessTeammates = !showSpinnerTree && hasBackgroundTasks && Object.values(tasks).some(t_1 => t_1.type === 'in_process_teammate');
+  const hasTeammatePills = hasInProcessTeammates || !showSpinnerTree && isViewingTeammate;
+
+  // In remote mode (`claude assistant`, --teleport) the agent runs elsewhere;
+  // the local permission mode shown here doesn't reflect the agent's state.
+  // Rendered before the tasks pill so a long pill label (e.g. ultraplan URL)
+  // doesn't push the mode indicator off-screen.
+  const modePart = currentMode && hasActiveMode && !getIsRemoteMode() ? <Text color={getModeColor(currentMode)} key="mode">
+        {permissionModeSymbol(currentMode)}{' '}
+        {permissionModeTitle(currentMode).toLowerCase()} on
+        {shouldShowModeHint && <Text dimColor>
+            {' '}
+            <KeyboardShortcutHint shortcut={modeCycleShortcut} action="cycle" parens />
+          </Text>}
+      </Text> : null;
+
+  // Build parts array - exclude BackgroundTaskStatus when we have teammate pills
+  // (teammate pills get their own row)
+  const parts = [
+  // Remote session indicator
+  ...(remoteSessionUrl ? [<Link url={remoteSessionUrl} key="remote">
+            <Text color="ide">{figures.circleDouble} remote</Text>
+          </Link>] : []),
+  // BackgroundTaskStatus is NOT in parts — it renders as a Box sibling so
+  // its click-target Box isn't nested inside the <Text wrap="truncate">
+  // wrapper (reconciler throws on Box-in-Text).
+  // Tmux pill (ant-only) — appears right after tasks in nav order
+  ...("external" === 'ant' && hasTmuxSession ? [<TungstenPill key="tmux" selected={tmuxSelected} />] : []), ...(isAgentSwarmsEnabled() && hasTeams ? [<TeamStatus key="teams" teamsSelected={teamsSelected} showHint={showHint && !hasBackgroundTasks} />] : []), ...(shouldShowPrStatus ? [<PrBadge key="pr-status" number={prStatus.number!} url={prStatus.url!} reviewState={prStatus.reviewState!} />] : [])];
+
+  // Check if any in-process teammates exist (for hint text cycling)
+  const hasAnyInProcessTeammates = Object.values(tasks).some(t_2 => t_2.type === 'in_process_teammate' && t_2.status === 'running');
+  const hasRunningAgentTasks = Object.values(tasks).some(t_3 => t_3.type === 'local_agent' && t_3.status === 'running');
+
+  // Get hint parts separately for potential second-line rendering
+  const hintParts = showHint ? getSpinnerHintParts(isLoading, escShortcut, todosShortcut, killAgentsShortcut, hasTaskItems, expandedView, hasAnyInProcessTeammates, hasRunningAgentTasks, isKillAgentsConfirmShowing) : [];
+  if (isViewingCompletedTeammate) {
+    parts.push(<Text dimColor key="esc-return">
+        <KeyboardShortcutHint shortcut={escShortcut} action="return to team lead" />
+      </Text>);
+  } else if ((feature('PROACTIVE') || feature('KAIROS')) && hasNextTick) {
+    parts.push(<ProactiveCountdown key="proactive" />);
+  } else if (!hasTeammatePills && showHint) {
+    parts.push(...hintParts);
+  }
+
+  // When we have teammate pills, always render them on their own line above other parts
+  if (hasTeammatePills) {
+    // Don't append spinner hints when viewing a completed teammate —
+    // the "esc to return to team lead" hint already replaces "esc to interrupt"
+    const otherParts = [...(modePart ? [modePart] : []), ...parts, ...(isViewingCompletedTeammate ? [] : hintParts)];
+    return <Box flexDirection="column">
+        <Box>
+          <BackgroundTaskStatus tasksSelected={tasksSelected} isViewingTeammate={isViewingTeammate} teammateFooterIndex={teammateFooterIndex} isLeaderIdle={!isLoading} onOpenDialog={onOpenTasksDialog} />
+        </Box>
+        {otherParts.length > 0 && <Box>
+            <Byline>{otherParts}</Byline>
+          </Box>}
+      </Box>;
+  }
+
+  // Add "↓ to manage tasks" hint when panel has visible rows
+  const hasCoordinatorTasks = "external" === 'ant' && getVisibleAgentTasks(tasks).length > 0;
+
+  // Tasks pill renders as a Box sibling (not a parts entry) so its
+  // click-target Box isn't nested inside <Text wrap="truncate"> — the
+  // reconciler throws on Box-in-Text. Computed here so the empty-checks
+  // below still treat "pill present" as non-empty.
+  const tasksPart = hasBackgroundTasks && !hasTeammatePills && !shouldHideTasksFooter(tasks, showSpinnerTree) ? <BackgroundTaskStatus tasksSelected={tasksSelected} isViewingTeammate={isViewingTeammate} teammateFooterIndex={teammateFooterIndex} isLeaderIdle={!isLoading} onOpenDialog={onOpenTasksDialog} /> : null;
+  if (parts.length === 0 && !tasksPart && !modePart && showHint) {
+    parts.push(<Text dimColor key="shortcuts-hint">
+        ? for shortcuts
+      </Text>);
+  }
+
+  // Only replace the idle voice hint when there's something to say — otherwise
+  // fall through instead of showing an empty Byline. "esc to clear" was removed
+  // (looked like "esc to interrupt" when idle; esc-clears-selection is standard
+  // UX) leaving only ctrl+c (copyOnSelect off) and the xterm.js native-select hint.
+  const copyOnSelect = getGlobalConfig().copyOnSelect ?? true;
+  const selectionHintHasContent = hasSelection && (!copyOnSelect || isXtermJs());
+
+  // Warmup hint takes priority — when the user is actively holding
+  // the activation key, show feedback regardless of other hints.
+  if (feature('VOICE_MODE') && voiceEnabled && voiceWarmingUp) {
+    parts.push(<VoiceWarmupHint key="voice-warmup" />);
+  } else if (isFullscreenEnvEnabled() && selectionHintHasContent) {
+    // xterm.js (VS Code/Cursor/Windsurf) force-selection modifier is
+    // platform-specific and gated on macOS (SelectionService.shouldForceSelection):
+    //   macOS:     altKey && macOptionClickForcesSelection (VS Code default: false)
+    //   non-macOS: shiftKey
+    // On macOS, if we RECEIVED an alt+click (lastPressHadAlt), the VS Code
+    // setting is off — xterm.js would have consumed the event otherwise.
+    // Tell the user the exact setting to flip instead of repeating the
+    // option+click hint they just tried.
+    // Non-reactive getState() read is safe: lastPressHadAlt is immutable
+    // while hasSelection is true (set pre-drag, cleared with selection).
+    const isMac = getPlatform() === 'macos';
+    const altClickFailed = isMac && (selGetState()?.lastPressHadAlt ?? false);
+    parts.push(<Text dimColor key="selection-copy">
+        <Byline>
+          {!copyOnSelect && <KeyboardShortcutHint shortcut="ctrl+c" action="copy" />}
+          {isXtermJs() && (altClickFailed ? <Text>set macOptionClickForcesSelection in VS Code settings</Text> : <KeyboardShortcutHint shortcut={isMac ? 'option+click' : 'shift+click'} action="native select" />)}
+        </Byline>
+      </Text>);
+  } else if (feature('VOICE_MODE') && parts.length > 0 && showHint && voiceEnabled && voiceState === 'idle' && hintParts.length === 0 && voiceHintUnderCap) {
+    parts.push(<Text dimColor key="voice-hint">
+        hold {voiceKeyShortcut} to speak
+      </Text>);
+  }
+  if ((tasksPart || hasCoordinatorTasks) && showHint && !hasTeams) {
+    parts.push(<Text dimColor key="manage-tasks">
+        {tasksSelected ? <KeyboardShortcutHint shortcut="Enter" action="view tasks" /> : <KeyboardShortcutHint shortcut="↓" action="manage" />}
+      </Text>);
+  }
+
+  // In fullscreen the bottom section is flexShrink:0 — every row here
+  // is a row stolen from the ScrollBox. This component must have a STABLE
+  // height so the footer never grows/shrinks and shifts scroll content.
+  // Returning null when parts is empty (e.g. StatusLine on → suppressHint
+  // → showHint=false → no "? for shortcuts") would let a later-added
+  // part (e.g. the selection copy/native-select hints) grow the column
+  // from 0→1 row. Always render 1 row in fullscreen; return a space when
+  // empty so Yoga reserves the row without painting anything visible.
+  if (parts.length === 0 && !tasksPart && !modePart) {
+    return isFullscreenEnvEnabled() ? <Text> </Text> : null;
+  }
+
+  // flexShrink=0 keeps mode + pill at natural width; the remaining parts
+  // truncate at the tail as one string inside the Text wrapper.
+  return <Box height={1} overflow="hidden">
+      {modePart && <Box flexShrink={0}>
+          {modePart}
+          {(tasksPart || parts.length > 0) && <Text dimColor> · </Text>}
+        </Box>}
+      {tasksPart && <Box flexShrink={0}>
+          {tasksPart}
+          {parts.length > 0 && <Text dimColor> · </Text>}
+        </Box>}
+      {parts.length > 0 && <Text wrap="truncate">
+          <Byline>{parts}</Byline>
+        </Text>}
+    </Box>;
+}
+function getSpinnerHintParts(isLoading: boolean, escShortcut: string, todosShortcut: string, killAgentsShortcut: string, hasTaskItems: boolean, expandedView: 'none' | 'tasks' | 'teammates', hasTeammates: boolean, hasRunningAgentTasks: boolean, isKillAgentsConfirmShowing: boolean): React.ReactElement[] {
+  let toggleAction: string;
+  if (hasTeammates) {
+    // Cycling: none → tasks → teammates → none
+    switch (expandedView) {
+      case 'none':
+        toggleAction = 'show tasks';
+        break;
+      case 'tasks':
+        toggleAction = 'show teammates';
+        break;
+      case 'teammates':
+        toggleAction = 'hide';
+        break;
+    }
+  } else {
+    toggleAction = expandedView === 'tasks' ? 'hide tasks' : 'show tasks';
+  }
+
+  // Show the toggle hint only when there are task items to display or
+  // teammates to cycle to
+  const showToggleHint = hasTaskItems || hasTeammates;
+  return [...(isLoading ? [<Text dimColor key="esc">
+            <KeyboardShortcutHint shortcut={escShortcut} action="interrupt" />
+          </Text>] : []), ...(!isLoading && hasRunningAgentTasks && !isKillAgentsConfirmShowing ? [<Text dimColor key="kill-agents">
+            <KeyboardShortcutHint shortcut={killAgentsShortcut} action="stop agents" />
+          </Text>] : []), ...(showToggleHint ? [<Text dimColor key="toggle-tasks">
+            <KeyboardShortcutHint shortcut={todosShortcut} action={toggleAction} />
+          </Text>] : [])];
+}
+function isPrStatusEnabled(): boolean {
+  return getGlobalConfig().prStatusFooterEnabled ?? true;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","coordinatorModule","require","undefined","Box","Text","Link","React","figures","useEffect","useMemo","useRef","useState","useSyncExternalStore","VimMode","PromptInputMode","ToolPermissionContext","isVimModeEnabled","useShortcutDisplay","isDefaultMode","permissionModeSymbol","permissionModeTitle","getModeColor","BackgroundTaskStatus","isBackgroundTask","isPanelAgentTask","getVisibleAgentTasks","count","shouldHideTasksFooter","isAgentSwarmsEnabled","TeamStatus","isInProcessEnabled","useAppState","useAppStateStore","getIsRemoteMode","HistorySearchInput","usePrStatus","KeyboardShortcutHint","Byline","useTerminalSize","useTasksV2","formatDuration","VoiceWarmupHint","useVoiceEnabled","useVoiceState","isFullscreenEnvEnabled","isXtermJs","useHasSelection","useSelection","getGlobalConfig","saveGlobalConfig","getPlatform","PrBadge","proactiveModule","NO_OP_SUBSCRIBE","_cb","NULL","MAX_VOICE_HINT_SHOWS","Props","exitMessage","show","key","vimMode","mode","toolPermissionContext","suppressHint","isLoading","showMemoryTypeSelector","tasksSelected","teamsSelected","tmuxSelected","teammateFooterIndex","isPasting","isSearching","historyQuery","setHistoryQuery","query","historyFailedMatch","onOpenTasksDialog","taskId","ProactiveCountdown","$","_c","nextTickAt","subscribeToProactiveChanges","getNextTickAt","remainingSeconds","setRemainingSeconds","t0","t1","update","remaining","Math","max","ceil","Date","now","interval","setInterval","clearInterval","t2","t3","mostSignificantOnly","t4","PromptInputFooterLeftSide","Symbol","for","showVim","t5","t6","ModeIndicatorProps","showHint","ModeIndicator","ReactNode","columns","modeCycleShortcut","tasks","s","teamContext","store","remoteSessionUrl","getState","viewSelectionMode","viewingAgentTaskId","expandedView","showSpinnerTree","prStatus","isPrStatusEnabled","hasTmuxSession","tungstenActiveSession","voiceEnabled","voiceState","const","voiceWarmingUp","hasSelection","selGetState","hasNextTick","isCoordinator","isCoordinatorMode","runningTaskCount","Object","values","t","tasksV2","hasTaskItems","length","escShortcut","toLowerCase","todosShortcut","killAgentsShortcut","voiceKeyShortcut","voiceHintUnderCap","voiceFooterHintSeenCount","voiceHintIncrementedRef","current","newCount","prev","isKillAgentsConfirmShowing","notifications","hasTeams","teammates","name","currentMode","hasActiveMode","viewedTask","isViewingTeammate","type","isViewingCompletedTeammate","status","hasBackgroundTasks","primaryItemCount","shouldShowPrStatus","number","reviewState","url","shouldShowModeHint","hasInProcessTeammates","some","hasTeammatePills","modePart","parts","circleDouble","hasAnyInProcessTeammates","hasRunningAgentTasks","hintParts","getSpinnerHintParts","push","otherParts","hasCoordinatorTasks","tasksPart","copyOnSelect","selectionHintHasContent","isMac","altClickFailed","lastPressHadAlt","hasTeammates","ReactElement","toggleAction","showToggleHint","prStatusFooterEnabled"],"sources":["PromptInputFooterLeftSide.tsx"],"sourcesContent":["// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered\nimport { feature } from 'bun:bundle'\n// Dead code elimination: conditional import for COORDINATOR_MODE\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst coordinatorModule = feature('COORDINATOR_MODE')\n  ? (require('../../coordinator/coordinatorMode.js') as typeof import('../../coordinator/coordinatorMode.js'))\n  : undefined\n/* eslint-enable @typescript-eslint/no-require-imports */\nimport { Box, Text, Link } from '../../ink.js'\nimport * as React from 'react'\nimport figures from 'figures'\nimport {\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from 'react'\nimport type { VimMode, PromptInputMode } from '../../types/textInputTypes.js'\nimport type { ToolPermissionContext } from '../../Tool.js'\nimport { isVimModeEnabled } from './utils.js'\nimport { useShortcutDisplay } from '../../keybindings/useShortcutDisplay.js'\nimport {\n  isDefaultMode,\n  permissionModeSymbol,\n  permissionModeTitle,\n  getModeColor,\n} from '../../utils/permissions/PermissionMode.js'\nimport { BackgroundTaskStatus } from '../tasks/BackgroundTaskStatus.js'\nimport { isBackgroundTask } from '../../tasks/types.js'\nimport { isPanelAgentTask } from '../../tasks/LocalAgentTask/LocalAgentTask.js'\nimport { getVisibleAgentTasks } from '../CoordinatorAgentStatus.js'\nimport { count } from '../../utils/array.js'\nimport { shouldHideTasksFooter } from '../tasks/taskStatusUtils.js'\nimport { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'\nimport { TeamStatus } from '../teams/TeamStatus.js'\nimport { isInProcessEnabled } from '../../utils/swarm/backends/registry.js'\nimport { useAppState, useAppStateStore } from 'src/state/AppState.js'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\nimport HistorySearchInput from './HistorySearchInput.js'\nimport { usePrStatus } from '../../hooks/usePrStatus.js'\nimport { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js'\nimport { Byline } from '../design-system/Byline.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { useTasksV2 } from '../../hooks/useTasksV2.js'\nimport { formatDuration } from '../../utils/format.js'\nimport { VoiceWarmupHint } from './VoiceIndicator.js'\nimport { useVoiceEnabled } from '../../hooks/useVoiceEnabled.js'\nimport { useVoiceState } from '../../context/voice.js'\nimport { isFullscreenEnvEnabled } from '../../utils/fullscreen.js'\nimport { isXtermJs } from '../../ink/terminal.js'\nimport { useHasSelection, useSelection } from '../../ink/hooks/use-selection.js'\nimport { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport { PrBadge } from '../PrBadge.js'\n\n// Dead code elimination: conditional import for proactive mode\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst proactiveModule =\n  feature('PROACTIVE') || feature('KAIROS')\n    ? require('../../proactive/index.js')\n    : null\n/* eslint-enable @typescript-eslint/no-require-imports */\nconst NO_OP_SUBSCRIBE = (_cb: () => void) => () => {}\nconst NULL = () => null\nconst MAX_VOICE_HINT_SHOWS = 3\n\ntype Props = {\n  exitMessage: {\n    show: boolean\n    key?: string\n  }\n  vimMode: VimMode | undefined\n  mode: PromptInputMode\n  toolPermissionContext: ToolPermissionContext\n  suppressHint: boolean\n  isLoading: boolean\n  showMemoryTypeSelector?: boolean\n  tasksSelected: boolean\n  teamsSelected: boolean\n  tmuxSelected: boolean\n  teammateFooterIndex?: number\n  isPasting?: boolean\n  isSearching: boolean\n  historyQuery: string\n  setHistoryQuery: (query: string) => void\n  historyFailedMatch: boolean\n  onOpenTasksDialog?: (taskId?: string) => void\n}\n\nfunction ProactiveCountdown(): React.ReactNode {\n  const nextTickAt = useSyncExternalStore(\n    proactiveModule?.subscribeToProactiveChanges ?? NO_OP_SUBSCRIBE,\n    proactiveModule?.getNextTickAt ?? NULL,\n    NULL,\n  )\n\n  const [remainingSeconds, setRemainingSeconds] = useState<number | null>(null)\n\n  useEffect(() => {\n    if (nextTickAt === null) {\n      setRemainingSeconds(null)\n      return\n    }\n\n    function update(): void {\n      const remaining = Math.max(\n        0,\n        Math.ceil((nextTickAt! - Date.now()) / 1000),\n      )\n      setRemainingSeconds(remaining)\n    }\n\n    update()\n    const interval = setInterval(update, 1000)\n    return () => clearInterval(interval)\n  }, [nextTickAt])\n\n  if (remainingSeconds === null) return null\n\n  return (\n    <Text dimColor>\n      waiting{' '}\n      {formatDuration(remainingSeconds * 1000, { mostSignificantOnly: true })}\n    </Text>\n  )\n}\n\nexport function PromptInputFooterLeftSide({\n  exitMessage,\n  vimMode,\n  mode,\n  toolPermissionContext,\n  suppressHint,\n  isLoading,\n  tasksSelected,\n  teamsSelected,\n  tmuxSelected,\n  teammateFooterIndex,\n  isPasting,\n  isSearching,\n  historyQuery,\n  setHistoryQuery,\n  historyFailedMatch,\n  onOpenTasksDialog,\n}: Props): React.ReactNode {\n  if (exitMessage.show) {\n    return (\n      <Text dimColor key=\"exit-message\">\n        Press {exitMessage.key} again to exit\n      </Text>\n    )\n  }\n  if (isPasting) {\n    return (\n      <Text dimColor key=\"pasting-message\">\n        Pasting text…\n      </Text>\n    )\n  }\n\n  const showVim = isVimModeEnabled() && vimMode === 'INSERT' && !isSearching\n\n  return (\n    <Box justifyContent=\"flex-start\" gap={1}>\n      {isSearching && (\n        <HistorySearchInput\n          value={historyQuery}\n          onChange={setHistoryQuery}\n          historyFailedMatch={historyFailedMatch}\n        />\n      )}\n      {showVim ? (\n        <Text dimColor key=\"vim-insert\">\n          -- INSERT --\n        </Text>\n      ) : null}\n      <ModeIndicator\n        mode={mode}\n        toolPermissionContext={toolPermissionContext}\n        showHint={!suppressHint && !showVim}\n        isLoading={isLoading}\n        tasksSelected={tasksSelected}\n        teamsSelected={teamsSelected}\n        teammateFooterIndex={teammateFooterIndex}\n        tmuxSelected={tmuxSelected}\n        onOpenTasksDialog={onOpenTasksDialog}\n      />\n    </Box>\n  )\n}\n\ntype ModeIndicatorProps = {\n  mode: PromptInputMode\n  toolPermissionContext: ToolPermissionContext\n  showHint: boolean\n  isLoading: boolean\n  tasksSelected: boolean\n  teamsSelected: boolean\n  tmuxSelected: boolean\n  teammateFooterIndex?: number\n  onOpenTasksDialog?: (taskId?: string) => void\n}\n\nfunction ModeIndicator({\n  mode,\n  toolPermissionContext,\n  showHint,\n  isLoading,\n  tasksSelected,\n  teamsSelected,\n  tmuxSelected,\n  teammateFooterIndex,\n  onOpenTasksDialog,\n}: ModeIndicatorProps): React.ReactNode {\n  const { columns } = useTerminalSize()\n  const modeCycleShortcut = useShortcutDisplay(\n    'chat:cycleMode',\n    'Chat',\n    'shift+tab',\n  )\n  const tasks = useAppState(s => s.tasks)\n  const teamContext = useAppState(s => s.teamContext)\n  // Set once in initialState (main.tsx --remote mode) and never mutated — lazy\n  // init captures the immutable value without a subscription.\n  const store = useAppStateStore()\n  const [remoteSessionUrl] = useState(() => store.getState().remoteSessionUrl)\n  const viewSelectionMode = useAppState(s => s.viewSelectionMode)\n  const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId)\n  const expandedView = useAppState(s => s.expandedView)\n  const showSpinnerTree = expandedView === 'teammates'\n  const prStatus = usePrStatus(isLoading, isPrStatusEnabled())\n  const hasTmuxSession = useAppState(\n    s =>\n      \"external\" === 'ant' && s.tungstenActiveSession !== undefined,\n  )\n\n  const nextTickAt = useSyncExternalStore(\n    proactiveModule?.subscribeToProactiveChanges ?? NO_OP_SUBSCRIBE,\n    proactiveModule?.getNextTickAt ?? NULL,\n    NULL,\n  )\n  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n  const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false\n  const voiceState = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceState)\n    : ('idle' as const)\n  const voiceWarmingUp = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceWarmingUp)\n    : false\n  const hasSelection = useHasSelection()\n  const selGetState = useSelection().getState\n  const hasNextTick = nextTickAt !== null\n  const isCoordinator = feature('COORDINATOR_MODE')\n    ? coordinatorModule?.isCoordinatorMode() === true\n    : false\n  const runningTaskCount = useMemo(\n    () =>\n      count(\n        Object.values(tasks),\n        t =>\n          isBackgroundTask(t) &&\n          !(\"external\" === 'ant' && isPanelAgentTask(t)),\n      ),\n    [tasks],\n  )\n  const tasksV2 = useTasksV2()\n  const hasTaskItems = tasksV2 !== undefined && tasksV2.length > 0\n  const escShortcut = useShortcutDisplay(\n    'chat:cancel',\n    'Chat',\n    'esc',\n  ).toLowerCase()\n  const todosShortcut = useShortcutDisplay(\n    'app:toggleTodos',\n    'Global',\n    'ctrl+t',\n  )\n  const killAgentsShortcut = useShortcutDisplay(\n    'chat:killAgents',\n    'Chat',\n    'ctrl+x ctrl+k',\n  )\n  const voiceKeyShortcut = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useShortcutDisplay('voice:pushToTalk', 'Chat', 'Space')\n    : ''\n  // Captured at mount so the hint doesn't flicker mid-session if another\n  // CC instance increments the counter. Incremented once via useEffect the\n  // first time voice is enabled in this session — approximates \"hint was\n  // shown\" without tracking the exact render-time condition (which depends\n  // on parts/hintParts computed after the early-return hooks boundary).\n  const [voiceHintUnderCap] = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useState(\n        () =>\n          (getGlobalConfig().voiceFooterHintSeenCount ?? 0) <\n          MAX_VOICE_HINT_SHOWS,\n      )\n    : [false]\n  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n  const voiceHintIncrementedRef = feature('VOICE_MODE') ? useRef(false) : null\n  useEffect(() => {\n    if (feature('VOICE_MODE')) {\n      if (!voiceEnabled || !voiceHintUnderCap) return\n      if (voiceHintIncrementedRef?.current) return\n      if (voiceHintIncrementedRef) voiceHintIncrementedRef.current = true\n      const newCount = (getGlobalConfig().voiceFooterHintSeenCount ?? 0) + 1\n      saveGlobalConfig(prev => {\n        if ((prev.voiceFooterHintSeenCount ?? 0) >= newCount) return prev\n        return { ...prev, voiceFooterHintSeenCount: newCount }\n      })\n    }\n  }, [voiceEnabled, voiceHintUnderCap])\n  const isKillAgentsConfirmShowing = useAppState(\n    s => s.notifications.current?.key === 'kill-agents-confirm',\n  )\n\n  // Derive team info from teamContext (no filesystem I/O needed)\n  // Match the same logic as TeamStatus to avoid trailing separator\n  // In-process mode uses Shift+Down/Up navigation, not footer teams menu\n  const hasTeams =\n    isAgentSwarmsEnabled() &&\n    !isInProcessEnabled() &&\n    teamContext !== undefined &&\n    count(Object.values(teamContext.teammates), t => t.name !== 'team-lead') > 0\n\n  if (mode === 'bash') {\n    return <Text color=\"bashBorder\">! for bash mode</Text>\n  }\n\n  const currentMode = toolPermissionContext?.mode\n  const hasActiveMode = !isDefaultMode(currentMode)\n  const viewedTask = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined\n  const isViewingTeammate =\n    viewSelectionMode === 'viewing-agent' &&\n    viewedTask?.type === 'in_process_teammate'\n  const isViewingCompletedTeammate =\n    isViewingTeammate && viewedTask != null && viewedTask.status !== 'running'\n  const hasBackgroundTasks = runningTaskCount > 0 || isViewingTeammate\n\n  // Count primary items (permission mode or coordinator mode, background tasks, and teams)\n  const primaryItemCount =\n    (isCoordinator || hasActiveMode ? 1 : 0) +\n    (hasBackgroundTasks ? 1 : 0) +\n    (hasTeams ? 1 : 0)\n\n  // PR indicator is short (~10 chars) — unlike the old diff indicator the\n  // >=100 threshold was tuned for. Now that auto mode is effectively the\n  // baseline, primaryItemCount is ≥1 for most sessions; keep the threshold\n  // low enough to show PR status on standard 80-col terminals.\n  const shouldShowPrStatus =\n    isPrStatusEnabled() &&\n    prStatus.number !== null &&\n    prStatus.reviewState !== null &&\n    prStatus.url !== null &&\n    primaryItemCount < 2 &&\n    (primaryItemCount === 0 || columns >= 80)\n\n  // Hide the shift+tab hint when there are 2 primary items\n  const shouldShowModeHint = primaryItemCount < 2\n\n  // Check if we have in-process teammates (showing pills)\n  // In spinner-tree mode, pills are disabled - teammates appear in the spinner tree instead\n  const hasInProcessTeammates =\n    !showSpinnerTree &&\n    hasBackgroundTasks &&\n    Object.values(tasks).some(t => t.type === 'in_process_teammate')\n  const hasTeammatePills =\n    hasInProcessTeammates || (!showSpinnerTree && isViewingTeammate)\n\n  // In remote mode (`claude assistant`, --teleport) the agent runs elsewhere;\n  // the local permission mode shown here doesn't reflect the agent's state.\n  // Rendered before the tasks pill so a long pill label (e.g. ultraplan URL)\n  // doesn't push the mode indicator off-screen.\n  const modePart =\n    currentMode && hasActiveMode && !getIsRemoteMode() ? (\n      <Text color={getModeColor(currentMode)} key=\"mode\">\n        {permissionModeSymbol(currentMode)}{' '}\n        {permissionModeTitle(currentMode).toLowerCase()} on\n        {shouldShowModeHint && (\n          <Text dimColor>\n            {' '}\n            <KeyboardShortcutHint\n              shortcut={modeCycleShortcut}\n              action=\"cycle\"\n              parens\n            />\n          </Text>\n        )}\n      </Text>\n    ) : null\n\n  // Build parts array - exclude BackgroundTaskStatus when we have teammate pills\n  // (teammate pills get their own row)\n  const parts = [\n    // Remote session indicator\n    ...(remoteSessionUrl\n      ? [\n          <Link url={remoteSessionUrl} key=\"remote\">\n            <Text color=\"ide\">{figures.circleDouble} remote</Text>\n          </Link>,\n        ]\n      : []),\n    // BackgroundTaskStatus is NOT in parts — it renders as a Box sibling so\n    // its click-target Box isn't nested inside the <Text wrap=\"truncate\">\n    // wrapper (reconciler throws on Box-in-Text).\n    // Tmux pill (ant-only) — appears right after tasks in nav order\n    ...(\"external\" === 'ant' && hasTmuxSession\n      ? [<TungstenPill key=\"tmux\" selected={tmuxSelected} />]\n      : []),\n    ...(isAgentSwarmsEnabled() && hasTeams\n      ? [\n          <TeamStatus\n            key=\"teams\"\n            teamsSelected={teamsSelected}\n            showHint={showHint && !hasBackgroundTasks}\n          />,\n        ]\n      : []),\n    ...(shouldShowPrStatus\n      ? [\n          <PrBadge\n            key=\"pr-status\"\n            number={prStatus.number!}\n            url={prStatus.url!}\n            reviewState={prStatus.reviewState!}\n          />,\n        ]\n      : []),\n  ]\n\n  // Check if any in-process teammates exist (for hint text cycling)\n  const hasAnyInProcessTeammates = Object.values(tasks).some(\n    t => t.type === 'in_process_teammate' && t.status === 'running',\n  )\n  const hasRunningAgentTasks = Object.values(tasks).some(\n    t => t.type === 'local_agent' && t.status === 'running',\n  )\n\n  // Get hint parts separately for potential second-line rendering\n  const hintParts = showHint\n    ? getSpinnerHintParts(\n        isLoading,\n        escShortcut,\n        todosShortcut,\n        killAgentsShortcut,\n        hasTaskItems,\n        expandedView,\n        hasAnyInProcessTeammates,\n        hasRunningAgentTasks,\n        isKillAgentsConfirmShowing,\n      )\n    : []\n\n  if (isViewingCompletedTeammate) {\n    parts.push(\n      <Text dimColor key=\"esc-return\">\n        <KeyboardShortcutHint\n          shortcut={escShortcut}\n          action=\"return to team lead\"\n        />\n      </Text>,\n    )\n  } else if ((feature('PROACTIVE') || feature('KAIROS')) && hasNextTick) {\n    parts.push(<ProactiveCountdown key=\"proactive\" />)\n  } else if (!hasTeammatePills && showHint) {\n    parts.push(...hintParts)\n  }\n\n  // When we have teammate pills, always render them on their own line above other parts\n  if (hasTeammatePills) {\n    // Don't append spinner hints when viewing a completed teammate —\n    // the \"esc to return to team lead\" hint already replaces \"esc to interrupt\"\n    const otherParts = [\n      ...(modePart ? [modePart] : []),\n      ...parts,\n      ...(isViewingCompletedTeammate ? [] : hintParts),\n    ]\n    return (\n      <Box flexDirection=\"column\">\n        <Box>\n          <BackgroundTaskStatus\n            tasksSelected={tasksSelected}\n            isViewingTeammate={isViewingTeammate}\n            teammateFooterIndex={teammateFooterIndex}\n            isLeaderIdle={!isLoading}\n            onOpenDialog={onOpenTasksDialog}\n          />\n        </Box>\n        {otherParts.length > 0 && (\n          <Box>\n            <Byline>{otherParts}</Byline>\n          </Box>\n        )}\n      </Box>\n    )\n  }\n\n  // Add \"↓ to manage tasks\" hint when panel has visible rows\n  const hasCoordinatorTasks =\n    \"external\" === 'ant' && getVisibleAgentTasks(tasks).length > 0\n\n  // Tasks pill renders as a Box sibling (not a parts entry) so its\n  // click-target Box isn't nested inside <Text wrap=\"truncate\"> — the\n  // reconciler throws on Box-in-Text. Computed here so the empty-checks\n  // below still treat \"pill present\" as non-empty.\n  const tasksPart =\n    hasBackgroundTasks &&\n    !hasTeammatePills &&\n    !shouldHideTasksFooter(tasks, showSpinnerTree) ? (\n      <BackgroundTaskStatus\n        tasksSelected={tasksSelected}\n        isViewingTeammate={isViewingTeammate}\n        teammateFooterIndex={teammateFooterIndex}\n        isLeaderIdle={!isLoading}\n        onOpenDialog={onOpenTasksDialog}\n      />\n    ) : null\n\n  if (parts.length === 0 && !tasksPart && !modePart && showHint) {\n    parts.push(\n      <Text dimColor key=\"shortcuts-hint\">\n        ? for shortcuts\n      </Text>,\n    )\n  }\n\n  // Only replace the idle voice hint when there's something to say — otherwise\n  // fall through instead of showing an empty Byline. \"esc to clear\" was removed\n  // (looked like \"esc to interrupt\" when idle; esc-clears-selection is standard\n  // UX) leaving only ctrl+c (copyOnSelect off) and the xterm.js native-select hint.\n  const copyOnSelect = getGlobalConfig().copyOnSelect ?? true\n  const selectionHintHasContent = hasSelection && (!copyOnSelect || isXtermJs())\n\n  // Warmup hint takes priority — when the user is actively holding\n  // the activation key, show feedback regardless of other hints.\n  if (feature('VOICE_MODE') && voiceEnabled && voiceWarmingUp) {\n    parts.push(<VoiceWarmupHint key=\"voice-warmup\" />)\n  } else if (isFullscreenEnvEnabled() && selectionHintHasContent) {\n    // xterm.js (VS Code/Cursor/Windsurf) force-selection modifier is\n    // platform-specific and gated on macOS (SelectionService.shouldForceSelection):\n    //   macOS:     altKey && macOptionClickForcesSelection (VS Code default: false)\n    //   non-macOS: shiftKey\n    // On macOS, if we RECEIVED an alt+click (lastPressHadAlt), the VS Code\n    // setting is off — xterm.js would have consumed the event otherwise.\n    // Tell the user the exact setting to flip instead of repeating the\n    // option+click hint they just tried.\n    // Non-reactive getState() read is safe: lastPressHadAlt is immutable\n    // while hasSelection is true (set pre-drag, cleared with selection).\n    const isMac = getPlatform() === 'macos'\n    const altClickFailed = isMac && (selGetState()?.lastPressHadAlt ?? false)\n    parts.push(\n      <Text dimColor key=\"selection-copy\">\n        <Byline>\n          {!copyOnSelect && (\n            <KeyboardShortcutHint shortcut=\"ctrl+c\" action=\"copy\" />\n          )}\n          {isXtermJs() &&\n            (altClickFailed ? (\n              <Text>set macOptionClickForcesSelection in VS Code settings</Text>\n            ) : (\n              <KeyboardShortcutHint\n                shortcut={isMac ? 'option+click' : 'shift+click'}\n                action=\"native select\"\n              />\n            ))}\n        </Byline>\n      </Text>,\n    )\n  } else if (\n    feature('VOICE_MODE') &&\n    parts.length > 0 &&\n    showHint &&\n    voiceEnabled &&\n    voiceState === 'idle' &&\n    hintParts.length === 0 &&\n    voiceHintUnderCap\n  ) {\n    parts.push(\n      <Text dimColor key=\"voice-hint\">\n        hold {voiceKeyShortcut} to speak\n      </Text>,\n    )\n  }\n\n  if ((tasksPart || hasCoordinatorTasks) && showHint && !hasTeams) {\n    parts.push(\n      <Text dimColor key=\"manage-tasks\">\n        {tasksSelected ? (\n          <KeyboardShortcutHint shortcut=\"Enter\" action=\"view tasks\" />\n        ) : (\n          <KeyboardShortcutHint shortcut=\"↓\" action=\"manage\" />\n        )}\n      </Text>,\n    )\n  }\n\n  // In fullscreen the bottom section is flexShrink:0 — every row here\n  // is a row stolen from the ScrollBox. This component must have a STABLE\n  // height so the footer never grows/shrinks and shifts scroll content.\n  // Returning null when parts is empty (e.g. StatusLine on → suppressHint\n  // → showHint=false → no \"? for shortcuts\") would let a later-added\n  // part (e.g. the selection copy/native-select hints) grow the column\n  // from 0→1 row. Always render 1 row in fullscreen; return a space when\n  // empty so Yoga reserves the row without painting anything visible.\n  if (parts.length === 0 && !tasksPart && !modePart) {\n    return isFullscreenEnvEnabled() ? <Text> </Text> : null\n  }\n\n  // flexShrink=0 keeps mode + pill at natural width; the remaining parts\n  // truncate at the tail as one string inside the Text wrapper.\n  return (\n    <Box height={1} overflow=\"hidden\">\n      {modePart && (\n        <Box flexShrink={0}>\n          {modePart}\n          {(tasksPart || parts.length > 0) && <Text dimColor> · </Text>}\n        </Box>\n      )}\n      {tasksPart && (\n        <Box flexShrink={0}>\n          {tasksPart}\n          {parts.length > 0 && <Text dimColor> · </Text>}\n        </Box>\n      )}\n      {parts.length > 0 && (\n        <Text wrap=\"truncate\">\n          <Byline>{parts}</Byline>\n        </Text>\n      )}\n    </Box>\n  )\n}\n\nfunction getSpinnerHintParts(\n  isLoading: boolean,\n  escShortcut: string,\n  todosShortcut: string,\n  killAgentsShortcut: string,\n  hasTaskItems: boolean,\n  expandedView: 'none' | 'tasks' | 'teammates',\n  hasTeammates: boolean,\n  hasRunningAgentTasks: boolean,\n  isKillAgentsConfirmShowing: boolean,\n): React.ReactElement[] {\n  let toggleAction: string\n  if (hasTeammates) {\n    // Cycling: none → tasks → teammates → none\n    switch (expandedView) {\n      case 'none':\n        toggleAction = 'show tasks'\n        break\n      case 'tasks':\n        toggleAction = 'show teammates'\n        break\n      case 'teammates':\n        toggleAction = 'hide'\n        break\n    }\n  } else {\n    toggleAction = expandedView === 'tasks' ? 'hide tasks' : 'show tasks'\n  }\n\n  // Show the toggle hint only when there are task items to display or\n  // teammates to cycle to\n  const showToggleHint = hasTaskItems || hasTeammates\n\n  return [\n    ...(isLoading\n      ? [\n          <Text dimColor key=\"esc\">\n            <KeyboardShortcutHint shortcut={escShortcut} action=\"interrupt\" />\n          </Text>,\n        ]\n      : []),\n    ...(!isLoading && hasRunningAgentTasks && !isKillAgentsConfirmShowing\n      ? [\n          <Text dimColor key=\"kill-agents\">\n            <KeyboardShortcutHint\n              shortcut={killAgentsShortcut}\n              action=\"stop agents\"\n            />\n          </Text>,\n        ]\n      : []),\n    ...(showToggleHint\n      ? [\n          <Text dimColor key=\"toggle-tasks\">\n            <KeyboardShortcutHint\n              shortcut={todosShortcut}\n              action={toggleAction}\n            />\n          </Text>,\n        ]\n      : []),\n  ]\n}\n\nfunction isPrStatusEnabled(): boolean {\n  return getGlobalConfig().prStatusFooterEnabled ?? true\n}\n"],"mappings":";AAAA;AACA,SAASA,OAAO,QAAQ,YAAY;AACpC;AACA;AACA,MAAMC,iBAAiB,GAAGD,OAAO,CAAC,kBAAkB,CAAC,GAChDE,OAAO,CAAC,sCAAsC,CAAC,IAAI,OAAO,OAAO,sCAAsC,CAAC,GACzGC,SAAS;AACb;AACA,SAASC,GAAG,EAAEC,IAAI,EAAEC,IAAI,QAAQ,cAAc;AAC9C,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,OAAOC,OAAO,MAAM,SAAS;AAC7B,SACEC,SAAS,EACTC,OAAO,EACPC,MAAM,EACNC,QAAQ,EACRC,oBAAoB,QACf,OAAO;AACd,cAAcC,OAAO,EAAEC,eAAe,QAAQ,+BAA+B;AAC7E,cAAcC,qBAAqB,QAAQ,eAAe;AAC1D,SAASC,gBAAgB,QAAQ,YAAY;AAC7C,SAASC,kBAAkB,QAAQ,yCAAyC;AAC5E,SACEC,aAAa,EACbC,oBAAoB,EACpBC,mBAAmB,EACnBC,YAAY,QACP,2CAA2C;AAClD,SAASC,oBAAoB,QAAQ,kCAAkC;AACvE,SAASC,gBAAgB,QAAQ,sBAAsB;AACvD,SAASC,gBAAgB,QAAQ,8CAA8C;AAC/E,SAASC,oBAAoB,QAAQ,8BAA8B;AACnE,SAASC,KAAK,QAAQ,sBAAsB;AAC5C,SAASC,qBAAqB,QAAQ,6BAA6B;AACnE,SAASC,oBAAoB,QAAQ,mCAAmC;AACxE,SAASC,UAAU,QAAQ,wBAAwB;AACnD,SAASC,kBAAkB,QAAQ,wCAAwC;AAC3E,SAASC,WAAW,EAAEC,gBAAgB,QAAQ,uBAAuB;AACrE,SAASC,eAAe,QAAQ,0BAA0B;AAC1D,OAAOC,kBAAkB,MAAM,yBAAyB;AACxD,SAASC,WAAW,QAAQ,4BAA4B;AACxD,SAASC,oBAAoB,QAAQ,0CAA0C;AAC/E,SAASC,MAAM,QAAQ,4BAA4B;AACnD,SAASC,eAAe,QAAQ,gCAAgC;AAChE,SAASC,UAAU,QAAQ,2BAA2B;AACtD,SAASC,cAAc,QAAQ,uBAAuB;AACtD,SAASC,eAAe,QAAQ,qBAAqB;AACrD,SAASC,eAAe,QAAQ,gCAAgC;AAChE,SAASC,aAAa,QAAQ,wBAAwB;AACtD,SAASC,sBAAsB,QAAQ,2BAA2B;AAClE,SAASC,SAAS,QAAQ,uBAAuB;AACjD,SAASC,eAAe,EAAEC,YAAY,QAAQ,kCAAkC;AAChF,SAASC,eAAe,EAAEC,gBAAgB,QAAQ,uBAAuB;AACzE,SAASC,WAAW,QAAQ,yBAAyB;AACrD,SAASC,OAAO,QAAQ,eAAe;;AAEvC;AACA;AACA,MAAMC,eAAe,GACnBrD,OAAO,CAAC,WAAW,CAAC,IAAIA,OAAO,CAAC,QAAQ,CAAC,GACrCE,OAAO,CAAC,0BAA0B,CAAC,GACnC,IAAI;AACV;AACA,MAAMoD,eAAe,GAAGA,CAACC,GAAG,EAAE,GAAG,GAAG,IAAI,KAAK,MAAM,CAAC,CAAC;AACrD,MAAMC,IAAI,GAAGA,CAAA,KAAM,IAAI;AACvB,MAAMC,oBAAoB,GAAG,CAAC;AAE9B,KAAKC,KAAK,GAAG;EACXC,WAAW,EAAE;IACXC,IAAI,EAAE,OAAO;IACbC,GAAG,CAAC,EAAE,MAAM;EACd,CAAC;EACDC,OAAO,EAAEhD,OAAO,GAAG,SAAS;EAC5BiD,IAAI,EAAEhD,eAAe;EACrBiD,qBAAqB,EAAEhD,qBAAqB;EAC5CiD,YAAY,EAAE,OAAO;EACrBC,SAAS,EAAE,OAAO;EAClBC,sBAAsB,CAAC,EAAE,OAAO;EAChCC,aAAa,EAAE,OAAO;EACtBC,aAAa,EAAE,OAAO;EACtBC,YAAY,EAAE,OAAO;EACrBC,mBAAmB,CAAC,EAAE,MAAM;EAC5BC,SAAS,CAAC,EAAE,OAAO;EACnBC,WAAW,EAAE,OAAO;EACpBC,YAAY,EAAE,MAAM;EACpBC,eAAe,EAAE,CAACC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;EACxCC,kBAAkB,EAAE,OAAO;EAC3BC,iBAAiB,CAAC,EAAE,CAACC,MAAe,CAAR,EAAE,MAAM,EAAE,GAAG,IAAI;AAC/C,CAAC;AAED,SAAAC,mBAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EACE,MAAAC,UAAA,GAAmBtE,oBAAoB,CACrCwC,eAAe,EAAA+B,2BAAgD,IAA/D9B,eAA+D,EAC/DD,eAAe,EAAAgC,aAAuB,IAAtC7B,IAAsC,EACtCA,IACF,CAAC;EAED,OAAA8B,gBAAA,EAAAC,mBAAA,IAAgD3E,QAAQ,CAAgB,IAAI,CAAC;EAAA,IAAA4E,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAR,CAAA,QAAAE,UAAA;IAEnEK,EAAA,GAAAA,CAAA;MACR,IAAIL,UAAU,KAAK,IAAI;QACrBI,mBAAmB,CAAC,IAAI,CAAC;QAAA;MAAA;MAI3B,MAAAG,MAAA,YAAAA,OAAA;QACE,MAAAC,SAAA,GAAkBC,IAAI,CAAAC,GAAI,CACxB,CAAC,EACDD,IAAI,CAAAE,IAAK,CAAC,CAACX,UAAU,GAAIY,IAAI,CAAAC,GAAI,CAAC,CAAC,IAAI,IAAI,CAC7C,CAAC;QACDT,mBAAmB,CAACI,SAAS,CAAC;MAAA,CAC/B;MAEDD,MAAM,CAAC,CAAC;MACR,MAAAO,QAAA,GAAiBC,WAAW,CAACR,MAAM,EAAE,IAAI,CAAC;MAAA,OACnC,MAAMS,aAAa,CAACF,QAAQ,CAAC;IAAA,CACrC;IAAER,EAAA,IAACN,UAAU,CAAC;IAAAF,CAAA,MAAAE,UAAA;IAAAF,CAAA,MAAAO,EAAA;IAAAP,CAAA,MAAAQ,EAAA;EAAA;IAAAD,EAAA,GAAAP,CAAA;IAAAQ,EAAA,GAAAR,CAAA;EAAA;EAjBfxE,SAAS,CAAC+E,EAiBT,EAAEC,EAAY,CAAC;EAEhB,IAAIH,gBAAgB,KAAK,IAAI;IAAA,OAAS,IAAI;EAAA;EAKtB,MAAAc,EAAA,GAAAd,gBAAgB,GAAG,IAAI;EAAA,IAAAe,EAAA;EAAA,IAAApB,CAAA,QAAAmB,EAAA;IAAtCC,EAAA,GAAA5D,cAAc,CAAC2D,EAAuB,EAAE;MAAAE,mBAAA,EAAuB;IAAK,CAAC,CAAC;IAAArB,CAAA,MAAAmB,EAAA;IAAAnB,CAAA,MAAAoB,EAAA;EAAA;IAAAA,EAAA,GAAApB,CAAA;EAAA;EAAA,IAAAsB,EAAA;EAAA,IAAAtB,CAAA,QAAAoB,EAAA;IAFzEE,EAAA,IAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,OACL,IAAE,CACT,CAAAF,EAAqE,CACxE,EAHC,IAAI,CAGE;IAAApB,CAAA,MAAAoB,EAAA;IAAApB,CAAA,MAAAsB,EAAA;EAAA;IAAAA,EAAA,GAAAtB,CAAA;EAAA;EAAA,OAHPsB,EAGO;AAAA;AAIX,OAAO,SAAAC,0BAAAhB,EAAA;EAAA,MAAAP,CAAA,GAAAC,EAAA;EAAmC;IAAAvB,WAAA;IAAAG,OAAA;IAAAC,IAAA;IAAAC,qBAAA;IAAAC,YAAA;IAAAC,SAAA;IAAAE,aAAA;IAAAC,aAAA;IAAAC,YAAA;IAAAC,mBAAA;IAAAC,SAAA;IAAAC,WAAA;IAAAC,YAAA;IAAAC,eAAA;IAAAE,kBAAA;IAAAC;EAAA,IAAAU,EAiBlC;EACN,IAAI7B,WAAW,CAAAC,IAAK;IAAA,IAAA6B,EAAA;IAAA,IAAAR,CAAA,QAAAtB,WAAA,CAAAE,GAAA;MAEhB4B,EAAA,IAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAK,GAAc,CAAd,cAAc,CAAC,MACzB,CAAA9B,WAAW,CAAAE,GAAG,CAAE,cACzB,EAFC,IAAI,CAEE;MAAAoB,CAAA,MAAAtB,WAAA,CAAAE,GAAA;MAAAoB,CAAA,MAAAQ,EAAA;IAAA;MAAAA,EAAA,GAAAR,CAAA;IAAA;IAAA,OAFPQ,EAEO;EAAA;EAGX,IAAIjB,SAAS;IAAA,IAAAiB,EAAA;IAAA,IAAAR,CAAA,QAAAwB,MAAA,CAAAC,GAAA;MAETjB,EAAA,IAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAK,GAAiB,CAAjB,iBAAiB,CAAC,aAErC,EAFC,IAAI,CAEE;MAAAR,CAAA,MAAAQ,EAAA;IAAA;MAAAA,EAAA,GAAAR,CAAA;IAAA;IAAA,OAFPQ,EAEO;EAAA;EAEV,IAAAA,EAAA;EAAA,IAAAR,CAAA,QAAAR,WAAA,IAAAQ,CAAA,QAAAnB,OAAA;IAEe2B,EAAA,GAAAxE,gBAAgB,CAAyB,CAAC,IAApB6C,OAAO,KAAK,QAAwB,IAA1D,CAA+CW,WAAW;IAAAQ,CAAA,MAAAR,WAAA;IAAAQ,CAAA,MAAAnB,OAAA;IAAAmB,CAAA,MAAAQ,EAAA;EAAA;IAAAA,EAAA,GAAAR,CAAA;EAAA;EAA1E,MAAA0B,OAAA,GAAgBlB,EAA0D;EAAA,IAAAW,EAAA;EAAA,IAAAnB,CAAA,QAAAJ,kBAAA,IAAAI,CAAA,QAAAP,YAAA,IAAAO,CAAA,QAAAR,WAAA,IAAAQ,CAAA,QAAAN,eAAA;IAIrEyB,EAAA,GAAA3B,WAMA,IALC,CAAC,kBAAkB,CACVC,KAAY,CAAZA,aAAW,CAAC,CACTC,QAAe,CAAfA,gBAAc,CAAC,CACLE,kBAAkB,CAAlBA,mBAAiB,CAAC,GAEzC;IAAAI,CAAA,MAAAJ,kBAAA;IAAAI,CAAA,MAAAP,YAAA;IAAAO,CAAA,MAAAR,WAAA;IAAAQ,CAAA,MAAAN,eAAA;IAAAM,CAAA,OAAAmB,EAAA;EAAA;IAAAA,EAAA,GAAAnB,CAAA;EAAA;EAAA,IAAAoB,EAAA;EAAA,IAAApB,CAAA,SAAA0B,OAAA;IACAN,EAAA,GAAAM,OAAO,GACN,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAK,GAAY,CAAZ,YAAY,CAAC,YAEhC,EAFC,IAAI,CAGC,GAJP,IAIO;IAAA1B,CAAA,OAAA0B,OAAA;IAAA1B,CAAA,OAAAoB,EAAA;EAAA;IAAAA,EAAA,GAAApB,CAAA;EAAA;EAII,MAAAsB,EAAA,IAACtC,YAAwB,IAAzB,CAAkB0C,OAAO;EAAA,IAAAC,EAAA;EAAA,IAAA3B,CAAA,SAAAf,SAAA,IAAAe,CAAA,SAAAlB,IAAA,IAAAkB,CAAA,SAAAH,iBAAA,IAAAG,CAAA,SAAAsB,EAAA,IAAAtB,CAAA,SAAAb,aAAA,IAAAa,CAAA,SAAAV,mBAAA,IAAAU,CAAA,SAAAZ,aAAA,IAAAY,CAAA,SAAAX,YAAA,IAAAW,CAAA,SAAAjB,qBAAA;IAHrC4C,EAAA,IAAC,aAAa,CACN7C,IAAI,CAAJA,KAAG,CAAC,CACaC,qBAAqB,CAArBA,sBAAoB,CAAC,CAClC,QAAyB,CAAzB,CAAAuC,EAAwB,CAAC,CACxBrC,SAAS,CAATA,UAAQ,CAAC,CACLE,aAAa,CAAbA,cAAY,CAAC,CACbC,aAAa,CAAbA,cAAY,CAAC,CACPE,mBAAmB,CAAnBA,oBAAkB,CAAC,CAC1BD,YAAY,CAAZA,aAAW,CAAC,CACPQ,iBAAiB,CAAjBA,kBAAgB,CAAC,GACpC;IAAAG,CAAA,OAAAf,SAAA;IAAAe,CAAA,OAAAlB,IAAA;IAAAkB,CAAA,OAAAH,iBAAA;IAAAG,CAAA,OAAAsB,EAAA;IAAAtB,CAAA,OAAAb,aAAA;IAAAa,CAAA,OAAAV,mBAAA;IAAAU,CAAA,OAAAZ,aAAA;IAAAY,CAAA,OAAAX,YAAA;IAAAW,CAAA,OAAAjB,qBAAA;IAAAiB,CAAA,OAAA2B,EAAA;EAAA;IAAAA,EAAA,GAAA3B,CAAA;EAAA;EAAA,IAAA4B,EAAA;EAAA,IAAA5B,CAAA,SAAAmB,EAAA,IAAAnB,CAAA,SAAAoB,EAAA,IAAApB,CAAA,SAAA2B,EAAA;IAvBJC,EAAA,IAAC,GAAG,CAAgB,cAAY,CAAZ,YAAY,CAAM,GAAC,CAAD,GAAC,CACpC,CAAAT,EAMD,CACC,CAAAC,EAIM,CACP,CAAAO,EAUC,CACH,EAxBC,GAAG,CAwBE;IAAA3B,CAAA,OAAAmB,EAAA;IAAAnB,CAAA,OAAAoB,EAAA;IAAApB,CAAA,OAAA2B,EAAA;IAAA3B,CAAA,OAAA4B,EAAA;EAAA;IAAAA,EAAA,GAAA5B,CAAA;EAAA;EAAA,OAxBN4B,EAwBM;AAAA;AAIV,KAAKC,kBAAkB,GAAG;EACxB/C,IAAI,EAAEhD,eAAe;EACrBiD,qBAAqB,EAAEhD,qBAAqB;EAC5C+F,QAAQ,EAAE,OAAO;EACjB7C,SAAS,EAAE,OAAO;EAClBE,aAAa,EAAE,OAAO;EACtBC,aAAa,EAAE,OAAO;EACtBC,YAAY,EAAE,OAAO;EACrBC,mBAAmB,CAAC,EAAE,MAAM;EAC5BO,iBAAiB,CAAC,EAAE,CAACC,MAAe,CAAR,EAAE,MAAM,EAAE,GAAG,IAAI;AAC/C,CAAC;AAED,SAASiC,aAAaA,CAAC;EACrBjD,IAAI;EACJC,qBAAqB;EACrB+C,QAAQ;EACR7C,SAAS;EACTE,aAAa;EACbC,aAAa;EACbC,YAAY;EACZC,mBAAmB;EACnBO;AACkB,CAAnB,EAAEgC,kBAAkB,CAAC,EAAEvG,KAAK,CAAC0G,SAAS,CAAC;EACtC,MAAM;IAAEC;EAAQ,CAAC,GAAG3E,eAAe,CAAC,CAAC;EACrC,MAAM4E,iBAAiB,GAAGjG,kBAAkB,CAC1C,gBAAgB,EAChB,MAAM,EACN,WACF,CAAC;EACD,MAAMkG,KAAK,GAAGpF,WAAW,CAACqF,CAAC,IAAIA,CAAC,CAACD,KAAK,CAAC;EACvC,MAAME,WAAW,GAAGtF,WAAW,CAACqF,GAAC,IAAIA,GAAC,CAACC,WAAW,CAAC;EACnD;EACA;EACA,MAAMC,KAAK,GAAGtF,gBAAgB,CAAC,CAAC;EAChC,MAAM,CAACuF,gBAAgB,CAAC,GAAG5G,QAAQ,CAAC,MAAM2G,KAAK,CAACE,QAAQ,CAAC,CAAC,CAACD,gBAAgB,CAAC;EAC5E,MAAME,iBAAiB,GAAG1F,WAAW,CAACqF,GAAC,IAAIA,GAAC,CAACK,iBAAiB,CAAC;EAC/D,MAAMC,kBAAkB,GAAG3F,WAAW,CAACqF,GAAC,IAAIA,GAAC,CAACM,kBAAkB,CAAC;EACjE,MAAMC,YAAY,GAAG5F,WAAW,CAACqF,GAAC,IAAIA,GAAC,CAACO,YAAY,CAAC;EACrD,MAAMC,eAAe,GAAGD,YAAY,KAAK,WAAW;EACpD,MAAME,QAAQ,GAAG1F,WAAW,CAAC8B,SAAS,EAAE6D,iBAAiB,CAAC,CAAC,CAAC;EAC5D,MAAMC,cAAc,GAAGhG,WAAW,CAChCqF,GAAC,IACC,UAAU,KAAK,KAAK,IAAIA,GAAC,CAACY,qBAAqB,KAAK9H,SACxD,CAAC;EAED,MAAMgF,UAAU,GAAGtE,oBAAoB,CACrCwC,eAAe,EAAE+B,2BAA2B,IAAI9B,eAAe,EAC/DD,eAAe,EAAEgC,aAAa,IAAI7B,IAAI,EACtCA,IACF,CAAC;EACD;EACA,MAAM0E,YAAY,GAAGlI,OAAO,CAAC,YAAY,CAAC,GAAG2C,eAAe,CAAC,CAAC,GAAG,KAAK;EACtE,MAAMwF,UAAU,GAAGnI,OAAO,CAAC,YAAY,CAAC;EACpC;EACA4C,aAAa,CAACyE,GAAC,IAAIA,GAAC,CAACc,UAAU,CAAC,GAC/B,MAAM,IAAIC,KAAM;EACrB,MAAMC,cAAc,GAAGrI,OAAO,CAAC,YAAY,CAAC;EACxC;EACA4C,aAAa,CAACyE,GAAC,IAAIA,GAAC,CAACgB,cAAc,CAAC,GACpC,KAAK;EACT,MAAMC,YAAY,GAAGvF,eAAe,CAAC,CAAC;EACtC,MAAMwF,WAAW,GAAGvF,YAAY,CAAC,CAAC,CAACyE,QAAQ;EAC3C,MAAMe,WAAW,GAAGrD,UAAU,KAAK,IAAI;EACvC,MAAMsD,aAAa,GAAGzI,OAAO,CAAC,kBAAkB,CAAC,GAC7CC,iBAAiB,EAAEyI,iBAAiB,CAAC,CAAC,KAAK,IAAI,GAC/C,KAAK;EACT,MAAMC,gBAAgB,GAAGjI,OAAO,CAC9B,MACEiB,KAAK,CACHiH,MAAM,CAACC,MAAM,CAACzB,KAAK,CAAC,EACpB0B,CAAC,IACCtH,gBAAgB,CAACsH,CAAC,CAAC,IACnB,EAAE,UAAU,KAAK,KAAK,IAAIrH,gBAAgB,CAACqH,CAAC,CAAC,CACjD,CAAC,EACH,CAAC1B,KAAK,CACR,CAAC;EACD,MAAM2B,OAAO,GAAGvG,UAAU,CAAC,CAAC;EAC5B,MAAMwG,YAAY,GAAGD,OAAO,KAAK5I,SAAS,IAAI4I,OAAO,CAACE,MAAM,GAAG,CAAC;EAChE,MAAMC,WAAW,GAAGhI,kBAAkB,CACpC,aAAa,EACb,MAAM,EACN,KACF,CAAC,CAACiI,WAAW,CAAC,CAAC;EACf,MAAMC,aAAa,GAAGlI,kBAAkB,CACtC,iBAAiB,EACjB,QAAQ,EACR,QACF,CAAC;EACD,MAAMmI,kBAAkB,GAAGnI,kBAAkB,CAC3C,iBAAiB,EACjB,MAAM,EACN,eACF,CAAC;EACD,MAAMoI,gBAAgB,GAAGtJ,OAAO,CAAC,YAAY,CAAC;EAC1C;EACAkB,kBAAkB,CAAC,kBAAkB,EAAE,MAAM,EAAE,OAAO,CAAC,GACvD,EAAE;EACN;EACA;EACA;EACA;EACA;EACA,MAAM,CAACqI,iBAAiB,CAAC,GAAGvJ,OAAO,CAAC,YAAY,CAAC;EAC7C;EACAY,QAAQ,CACN,MACE,CAACqC,eAAe,CAAC,CAAC,CAACuG,wBAAwB,IAAI,CAAC,IAChD/F,oBACJ,CAAC,GACD,CAAC,KAAK,CAAC;EACX;EACA,MAAMgG,uBAAuB,GAAGzJ,OAAO,CAAC,YAAY,CAAC,GAAGW,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;EAC5EF,SAAS,CAAC,MAAM;IACd,IAAIT,OAAO,CAAC,YAAY,CAAC,EAAE;MACzB,IAAI,CAACkI,YAAY,IAAI,CAACqB,iBAAiB,EAAE;MACzC,IAAIE,uBAAuB,EAAEC,OAAO,EAAE;MACtC,IAAID,uBAAuB,EAAEA,uBAAuB,CAACC,OAAO,GAAG,IAAI;MACnE,MAAMC,QAAQ,GAAG,CAAC1G,eAAe,CAAC,CAAC,CAACuG,wBAAwB,IAAI,CAAC,IAAI,CAAC;MACtEtG,gBAAgB,CAAC0G,IAAI,IAAI;QACvB,IAAI,CAACA,IAAI,CAACJ,wBAAwB,IAAI,CAAC,KAAKG,QAAQ,EAAE,OAAOC,IAAI;QACjE,OAAO;UAAE,GAAGA,IAAI;UAAEJ,wBAAwB,EAAEG;QAAS,CAAC;MACxD,CAAC,CAAC;IACJ;EACF,CAAC,EAAE,CAACzB,YAAY,EAAEqB,iBAAiB,CAAC,CAAC;EACrC,MAAMM,0BAA0B,GAAG7H,WAAW,CAC5CqF,GAAC,IAAIA,GAAC,CAACyC,aAAa,CAACJ,OAAO,EAAE7F,GAAG,KAAK,qBACxC,CAAC;;EAED;EACA;EACA;EACA,MAAMkG,QAAQ,GACZlI,oBAAoB,CAAC,CAAC,IACtB,CAACE,kBAAkB,CAAC,CAAC,IACrBuF,WAAW,KAAKnH,SAAS,IACzBwB,KAAK,CAACiH,MAAM,CAACC,MAAM,CAACvB,WAAW,CAAC0C,SAAS,CAAC,EAAElB,GAAC,IAAIA,GAAC,CAACmB,IAAI,KAAK,WAAW,CAAC,GAAG,CAAC;EAE9E,IAAIlG,IAAI,KAAK,MAAM,EAAE;IACnB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,eAAe,EAAE,IAAI,CAAC;EACxD;EAEA,MAAMmG,WAAW,GAAGlG,qBAAqB,EAAED,IAAI;EAC/C,MAAMoG,aAAa,GAAG,CAAChJ,aAAa,CAAC+I,WAAW,CAAC;EACjD,MAAME,UAAU,GAAGzC,kBAAkB,GAAGP,KAAK,CAACO,kBAAkB,CAAC,GAAGxH,SAAS;EAC7E,MAAMkK,iBAAiB,GACrB3C,iBAAiB,KAAK,eAAe,IACrC0C,UAAU,EAAEE,IAAI,KAAK,qBAAqB;EAC5C,MAAMC,0BAA0B,GAC9BF,iBAAiB,IAAID,UAAU,IAAI,IAAI,IAAIA,UAAU,CAACI,MAAM,KAAK,SAAS;EAC5E,MAAMC,kBAAkB,GAAG9B,gBAAgB,GAAG,CAAC,IAAI0B,iBAAiB;;EAEpE;EACA,MAAMK,gBAAgB,GACpB,CAACjC,aAAa,IAAI0B,aAAa,GAAG,CAAC,GAAG,CAAC,KACtCM,kBAAkB,GAAG,CAAC,GAAG,CAAC,CAAC,IAC3BV,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC;;EAEpB;EACA;EACA;EACA;EACA,MAAMY,kBAAkB,GACtB5C,iBAAiB,CAAC,CAAC,IACnBD,QAAQ,CAAC8C,MAAM,KAAK,IAAI,IACxB9C,QAAQ,CAAC+C,WAAW,KAAK,IAAI,IAC7B/C,QAAQ,CAACgD,GAAG,KAAK,IAAI,IACrBJ,gBAAgB,GAAG,CAAC,KACnBA,gBAAgB,KAAK,CAAC,IAAIxD,OAAO,IAAI,EAAE,CAAC;;EAE3C;EACA,MAAM6D,kBAAkB,GAAGL,gBAAgB,GAAG,CAAC;;EAE/C;EACA;EACA,MAAMM,qBAAqB,GACzB,CAACnD,eAAe,IAChB4C,kBAAkB,IAClB7B,MAAM,CAACC,MAAM,CAACzB,KAAK,CAAC,CAAC6D,IAAI,CAACnC,GAAC,IAAIA,GAAC,CAACwB,IAAI,KAAK,qBAAqB,CAAC;EAClE,MAAMY,gBAAgB,GACpBF,qBAAqB,IAAK,CAACnD,eAAe,IAAIwC,iBAAkB;;EAElE;EACA;EACA;EACA;EACA,MAAMc,QAAQ,GACZjB,WAAW,IAAIC,aAAa,IAAI,CAACjI,eAAe,CAAC,CAAC,GAChD,CAAC,IAAI,CAAC,KAAK,CAAC,CAACZ,YAAY,CAAC4I,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM;AACxD,QAAQ,CAAC9I,oBAAoB,CAAC8I,WAAW,CAAC,CAAC,CAAC,GAAG;AAC/C,QAAQ,CAAC7I,mBAAmB,CAAC6I,WAAW,CAAC,CAACf,WAAW,CAAC,CAAC,CAAC;AACxD,QAAQ,CAAC4B,kBAAkB,IACjB,CAAC,IAAI,CAAC,QAAQ;AACxB,YAAY,CAAC,GAAG;AAChB,YAAY,CAAC,oBAAoB,CACnB,QAAQ,CAAC,CAAC5D,iBAAiB,CAAC,CAC5B,MAAM,CAAC,OAAO,CACd,MAAM;AAEpB,UAAU,EAAE,IAAI,CACP;AACT,MAAM,EAAE,IAAI,CAAC,GACL,IAAI;;EAEV;EACA;EACA,MAAMiE,KAAK,GAAG;EACZ;EACA,IAAI5D,gBAAgB,GAChB,CACE,CAAC,IAAI,CAAC,GAAG,CAAC,CAACA,gBAAgB,CAAC,CAAC,GAAG,CAAC,QAAQ;AACnD,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAChH,OAAO,CAAC6K,YAAY,CAAC,OAAO,EAAE,IAAI;AACjE,UAAU,EAAE,IAAI,CAAC,CACR,GACD,EAAE,CAAC;EACP;EACA;EACA;EACA;EACA,IAAI,UAAU,KAAK,KAAK,IAAIrD,cAAc,GACtC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC1D,YAAY,CAAC,GAAG,CAAC,GACrD,EAAE,CAAC,EACP,IAAIzC,oBAAoB,CAAC,CAAC,IAAIkI,QAAQ,GAClC,CACE,CAAC,UAAU,CACT,GAAG,CAAC,OAAO,CACX,aAAa,CAAC,CAAC1F,aAAa,CAAC,CAC7B,QAAQ,CAAC,CAAC0C,QAAQ,IAAI,CAAC0D,kBAAkB,CAAC,GAC1C,CACH,GACD,EAAE,CAAC,EACP,IAAIE,kBAAkB,GAClB,CACE,CAAC,OAAO,CACN,GAAG,CAAC,WAAW,CACf,MAAM,CAAC,CAAC7C,QAAQ,CAAC8C,MAAM,CAAC,CAAC,CACzB,GAAG,CAAC,CAAC9C,QAAQ,CAACgD,GAAG,CAAC,CAAC,CACnB,WAAW,CAAC,CAAChD,QAAQ,CAAC+C,WAAW,CAAC,CAAC,GACnC,CACH,GACD,EAAE,CAAC,CACR;;EAED;EACA,MAAMS,wBAAwB,GAAG1C,MAAM,CAACC,MAAM,CAACzB,KAAK,CAAC,CAAC6D,IAAI,CACxDnC,GAAC,IAAIA,GAAC,CAACwB,IAAI,KAAK,qBAAqB,IAAIxB,GAAC,CAAC0B,MAAM,KAAK,SACxD,CAAC;EACD,MAAMe,oBAAoB,GAAG3C,MAAM,CAACC,MAAM,CAACzB,KAAK,CAAC,CAAC6D,IAAI,CACpDnC,GAAC,IAAIA,GAAC,CAACwB,IAAI,KAAK,aAAa,IAAIxB,GAAC,CAAC0B,MAAM,KAAK,SAChD,CAAC;;EAED;EACA,MAAMgB,SAAS,GAAGzE,QAAQ,GACtB0E,mBAAmB,CACjBvH,SAAS,EACTgF,WAAW,EACXE,aAAa,EACbC,kBAAkB,EAClBL,YAAY,EACZpB,YAAY,EACZ0D,wBAAwB,EACxBC,oBAAoB,EACpB1B,0BACF,CAAC,GACD,EAAE;EAEN,IAAIU,0BAA0B,EAAE;IAC9Ba,KAAK,CAACM,IAAI,CACR,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY;AACrC,QAAQ,CAAC,oBAAoB,CACnB,QAAQ,CAAC,CAACxC,WAAW,CAAC,CACtB,MAAM,CAAC,qBAAqB;AAEtC,MAAM,EAAE,IAAI,CACR,CAAC;EACH,CAAC,MAAM,IAAI,CAAClJ,OAAO,CAAC,WAAW,CAAC,IAAIA,OAAO,CAAC,QAAQ,CAAC,KAAKwI,WAAW,EAAE;IACrE4C,KAAK,CAACM,IAAI,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,WAAW,GAAG,CAAC;EACpD,CAAC,MAAM,IAAI,CAACR,gBAAgB,IAAInE,QAAQ,EAAE;IACxCqE,KAAK,CAACM,IAAI,CAAC,GAAGF,SAAS,CAAC;EAC1B;;EAEA;EACA,IAAIN,gBAAgB,EAAE;IACpB;IACA;IACA,MAAMS,UAAU,GAAG,CACjB,IAAIR,QAAQ,GAAG,CAACA,QAAQ,CAAC,GAAG,EAAE,CAAC,EAC/B,GAAGC,KAAK,EACR,IAAIb,0BAA0B,GAAG,EAAE,GAAGiB,SAAS,CAAC,CACjD;IACD,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ;AACjC,QAAQ,CAAC,GAAG;AACZ,UAAU,CAAC,oBAAoB,CACnB,aAAa,CAAC,CAACpH,aAAa,CAAC,CAC7B,iBAAiB,CAAC,CAACiG,iBAAiB,CAAC,CACrC,mBAAmB,CAAC,CAAC9F,mBAAmB,CAAC,CACzC,YAAY,CAAC,CAAC,CAACL,SAAS,CAAC,CACzB,YAAY,CAAC,CAACY,iBAAiB,CAAC;AAE5C,QAAQ,EAAE,GAAG;AACb,QAAQ,CAAC6G,UAAU,CAAC1C,MAAM,GAAG,CAAC,IACpB,CAAC,GAAG;AACd,YAAY,CAAC,MAAM,CAAC,CAAC0C,UAAU,CAAC,EAAE,MAAM;AACxC,UAAU,EAAE,GAAG,CACN;AACT,MAAM,EAAE,GAAG,CAAC;EAEV;;EAEA;EACA,MAAMC,mBAAmB,GACvB,UAAU,KAAK,KAAK,IAAIlK,oBAAoB,CAAC0F,KAAK,CAAC,CAAC6B,MAAM,GAAG,CAAC;;EAEhE;EACA;EACA;EACA;EACA,MAAM4C,SAAS,GACbpB,kBAAkB,IAClB,CAACS,gBAAgB,IACjB,CAACtJ,qBAAqB,CAACwF,KAAK,EAAES,eAAe,CAAC,GAC5C,CAAC,oBAAoB,CACnB,aAAa,CAAC,CAACzD,aAAa,CAAC,CAC7B,iBAAiB,CAAC,CAACiG,iBAAiB,CAAC,CACrC,mBAAmB,CAAC,CAAC9F,mBAAmB,CAAC,CACzC,YAAY,CAAC,CAAC,CAACL,SAAS,CAAC,CACzB,YAAY,CAAC,CAACY,iBAAiB,CAAC,GAChC,GACA,IAAI;EAEV,IAAIsG,KAAK,CAACnC,MAAM,KAAK,CAAC,IAAI,CAAC4C,SAAS,IAAI,CAACV,QAAQ,IAAIpE,QAAQ,EAAE;IAC7DqE,KAAK,CAACM,IAAI,CACR,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,gBAAgB;AACzC;AACA,MAAM,EAAE,IAAI,CACR,CAAC;EACH;;EAEA;EACA;EACA;EACA;EACA,MAAMI,YAAY,GAAG7I,eAAe,CAAC,CAAC,CAAC6I,YAAY,IAAI,IAAI;EAC3D,MAAMC,uBAAuB,GAAGzD,YAAY,KAAK,CAACwD,YAAY,IAAIhJ,SAAS,CAAC,CAAC,CAAC;;EAE9E;EACA;EACA,IAAI9C,OAAO,CAAC,YAAY,CAAC,IAAIkI,YAAY,IAAIG,cAAc,EAAE;IAC3D+C,KAAK,CAACM,IAAI,CAAC,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,GAAG,CAAC;EACpD,CAAC,MAAM,IAAI7I,sBAAsB,CAAC,CAAC,IAAIkJ,uBAAuB,EAAE;IAC9D;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMC,KAAK,GAAG7I,WAAW,CAAC,CAAC,KAAK,OAAO;IACvC,MAAM8I,cAAc,GAAGD,KAAK,KAAKzD,WAAW,CAAC,CAAC,EAAE2D,eAAe,IAAI,KAAK,CAAC;IACzEd,KAAK,CAACM,IAAI,CACR,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,gBAAgB;AACzC,QAAQ,CAAC,MAAM;AACf,UAAU,CAAC,CAACI,YAAY,IACZ,CAAC,oBAAoB,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,GACtD;AACX,UAAU,CAAChJ,SAAS,CAAC,CAAC,KACTmJ,cAAc,GACb,CAAC,IAAI,CAAC,qDAAqD,EAAE,IAAI,CAAC,GAElE,CAAC,oBAAoB,CACnB,QAAQ,CAAC,CAACD,KAAK,GAAG,cAAc,GAAG,aAAa,CAAC,CACjD,MAAM,CAAC,eAAe,GAEzB,CAAC;AACd,QAAQ,EAAE,MAAM;AAChB,MAAM,EAAE,IAAI,CACR,CAAC;EACH,CAAC,MAAM,IACLhM,OAAO,CAAC,YAAY,CAAC,IACrBoL,KAAK,CAACnC,MAAM,GAAG,CAAC,IAChBlC,QAAQ,IACRmB,YAAY,IACZC,UAAU,KAAK,MAAM,IACrBqD,SAAS,CAACvC,MAAM,KAAK,CAAC,IACtBM,iBAAiB,EACjB;IACA6B,KAAK,CAACM,IAAI,CACR,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY;AACrC,aAAa,CAACpC,gBAAgB,CAAC;AAC/B,MAAM,EAAE,IAAI,CACR,CAAC;EACH;EAEA,IAAI,CAACuC,SAAS,IAAID,mBAAmB,KAAK7E,QAAQ,IAAI,CAACgD,QAAQ,EAAE;IAC/DqB,KAAK,CAACM,IAAI,CACR,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc;AACvC,QAAQ,CAACtH,aAAa,GACZ,CAAC,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,GAAG,GAE7D,CAAC,oBAAoB,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,GACnD;AACT,MAAM,EAAE,IAAI,CACR,CAAC;EACH;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,IAAIgH,KAAK,CAACnC,MAAM,KAAK,CAAC,IAAI,CAAC4C,SAAS,IAAI,CAACV,QAAQ,EAAE;IACjD,OAAOtI,sBAAsB,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,IAAI;EACzD;;EAEA;EACA;EACA,OACE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ;AACrC,MAAM,CAACsI,QAAQ,IACP,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AAC3B,UAAU,CAACA,QAAQ;AACnB,UAAU,CAAC,CAACU,SAAS,IAAIT,KAAK,CAACnC,MAAM,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;AACvE,QAAQ,EAAE,GAAG,CACN;AACP,MAAM,CAAC4C,SAAS,IACR,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AAC3B,UAAU,CAACA,SAAS;AACpB,UAAU,CAACT,KAAK,CAACnC,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;AACxD,QAAQ,EAAE,GAAG,CACN;AACP,MAAM,CAACmC,KAAK,CAACnC,MAAM,GAAG,CAAC,IACf,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU;AAC7B,UAAU,CAAC,MAAM,CAAC,CAACmC,KAAK,CAAC,EAAE,MAAM;AACjC,QAAQ,EAAE,IAAI,CACP;AACP,IAAI,EAAE,GAAG,CAAC;AAEV;AAEA,SAASK,mBAAmBA,CAC1BvH,SAAS,EAAE,OAAO,EAClBgF,WAAW,EAAE,MAAM,EACnBE,aAAa,EAAE,MAAM,EACrBC,kBAAkB,EAAE,MAAM,EAC1BL,YAAY,EAAE,OAAO,EACrBpB,YAAY,EAAE,MAAM,GAAG,OAAO,GAAG,WAAW,EAC5CuE,YAAY,EAAE,OAAO,EACrBZ,oBAAoB,EAAE,OAAO,EAC7B1B,0BAA0B,EAAE,OAAO,CACpC,EAAEtJ,KAAK,CAAC6L,YAAY,EAAE,CAAC;EACtB,IAAIC,YAAY,EAAE,MAAM;EACxB,IAAIF,YAAY,EAAE;IAChB;IACA,QAAQvE,YAAY;MAClB,KAAK,MAAM;QACTyE,YAAY,GAAG,YAAY;QAC3B;MACF,KAAK,OAAO;QACVA,YAAY,GAAG,gBAAgB;QAC/B;MACF,KAAK,WAAW;QACdA,YAAY,GAAG,MAAM;QACrB;IACJ;EACF,CAAC,MAAM;IACLA,YAAY,GAAGzE,YAAY,KAAK,OAAO,GAAG,YAAY,GAAG,YAAY;EACvE;;EAEA;EACA;EACA,MAAM0E,cAAc,GAAGtD,YAAY,IAAImD,YAAY;EAEnD,OAAO,CACL,IAAIjI,SAAS,GACT,CACE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK;AAClC,YAAY,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAACgF,WAAW,CAAC,CAAC,MAAM,CAAC,WAAW;AAC3E,UAAU,EAAE,IAAI,CAAC,CACR,GACD,EAAE,CAAC,EACP,IAAI,CAAChF,SAAS,IAAIqH,oBAAoB,IAAI,CAAC1B,0BAA0B,GACjE,CACE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa;AAC1C,YAAY,CAAC,oBAAoB,CACnB,QAAQ,CAAC,CAACR,kBAAkB,CAAC,CAC7B,MAAM,CAAC,aAAa;AAElC,UAAU,EAAE,IAAI,CAAC,CACR,GACD,EAAE,CAAC,EACP,IAAIiD,cAAc,GACd,CACE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc;AAC3C,YAAY,CAAC,oBAAoB,CACnB,QAAQ,CAAC,CAAClD,aAAa,CAAC,CACxB,MAAM,CAAC,CAACiD,YAAY,CAAC;AAEnC,UAAU,EAAE,IAAI,CAAC,CACR,GACD,EAAE,CAAC,CACR;AACH;AAEA,SAAStE,iBAAiBA,CAAA,CAAE,EAAE,OAAO,CAAC;EACpC,OAAO9E,eAAe,CAAC,CAAC,CAACsJ,qBAAqB,IAAI,IAAI;AACxD","ignoreList":[]}