Function bodies 32 total

function getInitialTheme(): ThemeMode {
  const saved = localStorage.getItem("theme");
  if (saved === "dark" || saved === "light") return saved;
  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
}

function formatShortcutDisplay(shortcut: string): string {
  return shortcut
    .replace(/Alt/g, "⌥")
    .replace(/Shift/g, "⇧")
    .replace(/Control/g, "⌃")
    .replace(/Meta/g, "⌘")
    .replace(/Cmd/g, "⌘")
    .replace(/\+/g, " ");
}

function App() {
  const [mode, setMode] = useState("NORMAL");
  const [copied, setCopied] = useState(false);
  const [showSettings, setShowSettings] = useState(false);
  const [currentShortcut, setCurrentShortcut] = useState(DEFAULT_SHORTCUT);
  const [theme, setTheme] = useState<ThemeMode>(getInitialTheme);
  const [visibilitySettings, setVisibilitySettings] = useState<VisibilitySettings>({
    hide_menu_bar_icon: false,
  });

  const themeStyles = theme === "dark"
    ? {
        appBackground: "rgba(19, 20, 23, 0.55)",
        border: "1px solid rgba(255, 255, 255, 0.08)",
        shadow: "0 10px 24px rgba(0, 0, 0, 0.08), 0 28px 90px rgba(0, 0, 0, 0.24), 0 48px 140px rgba(0, 0, 0, 0.16), inset 0 1px 0 rgba(255, 255, 255, 0.16)",
      }
    : {
        appBackground: "rgba(255, 255, 255, 0.18)",
        border: "1px solid rgba(255, 255, 255, 0.22)",
        shadow: "0 8px 20px rgba(15, 23, 42, 0.06), 0 26px 80px rgba(15, 23, 42, 0.12), 0 42px 130px rgba(15, 23, 42, 0.08), inset 0 

function keyToCode(key: string, code: string): string | null {
  // Letter keys
  if (/^Key([A-Z])$/.test(code)) {
    return code.replace("Key", "");
  }
  // Digit keys
  if (/^Digit(\d)$/.test(code)) {
    return code.replace("Digit", "");
  }
  // Function keys
  if (/^F(\d+)$/.test(key)) {
    return key;
  }
  // Special keys mapping
  const specialMap: Record<string, string> = {
    " ": "Space",
    Space: "Space",
    Enter: "Enter",
    Tab: "Tab",
    Escape: "Escape",
    Backspace: "Backspace",
    Delete: "Delete",
    ArrowUp: "Up",
    ArrowDown: "Down",
    ArrowLeft: "Left",
    ArrowRight: "Right",
    Home: "Home",
    End: "End",
    PageUp: "PageUp",
    PageDown: "PageDown",
    Insert: "Insert",
    Minus: "-",
    Equal: "=",
    BracketLeft: "[",
    BracketRight: "]",
    Backslash: "\\",
    Semicolon: ";",
    Quote: "'",
    Comma: ",",
    Period: ".",
    Slash: "/",
    Backquote: "`",
  };

  if (specialMap[key]) return specialMap[key];
  if (specialMa

function formatShortcutDisplay(shortcut: string): string {
  return shortcut
    .replace(/Alt/g, "⌥")
    .replace(/Shift/g, "⇧")
    .replace(/Control/g, "⌃")
    .replace(/Meta/g, "⌘")
    .replace(/Cmd/g, "⌘")
    .replace(/\+/g, " ");
}

export default function ShortcutRecorder({
  currentShortcut,
  onShortcutChange,
  visibilitySettings,
  onVisibilitySettingsChange,
  onClose,
  theme,
}: ShortcutRecorderProps) {
  const [recording, setRecording] = useState(false);
  const [pendingShortcut, setPendingShortcut] = useState<string | null>(null);
  const recorderRef = useRef<HTMLDivElement>(null);
  const isDark = theme === "dark";
  const colors = isDark
    ? {
        overlay: "rgba(0, 0, 0, 0.6)",
        modal: "rgba(39, 39, 42, 0.98)",
        border: "1px solid rgba(255, 255, 255, 0.1)",
        subtleBorder: "1px solid rgba(255, 255, 255, 0.06)",
        title: "#e4e4e7",
        body: "#71717a",
        displayBorder: "1px solid rgba(255, 255, 255, 0.12)",
        displayBg: "rgba(255, 255, 255, 0.04)",
        text: "#e4e4e7",
        muted: "#52525b",
        buttonBorder: "1px solid rgba(255, 255, 255, 0.1)",
        buttonText: "#a1a1aa",
        buttonHover: "rgba(255, 255, 255, 0.06)",
      }
    : {
   

export default function StatusBar({ mode, copied, onCopyClick, theme }: StatusBarProps) {
  const modeColor = modeColors[mode] || "#a78bfa";
  const isDark = theme === "dark";
  const colors = isDark
    ? {
        background: "rgba(255, 255, 255, 0.04)",
        border: "1px solid rgba(255, 255, 255, 0.08)",
        appText: "rgba(255, 255, 255, 0.5)",
        hintText: "rgba(255, 255, 255, 0.3)",
        buttonBg: "rgba(255, 255, 255, 0.08)",
        buttonBgHover: "rgba(255, 255, 255, 0.14)",
        buttonText: "rgba(255, 255, 255, 0.72)",
        buttonTextHover: "#ffffff",
        kbdBg: "rgba(255, 255, 255, 0.09)",
        kbdBorder: "1px solid rgba(255, 255, 255, 0.12)",
        kbdText: "rgba(255, 255, 255, 0.46)",
      }
    : {
        background: "rgba(255, 255, 255, 0.08)",
        border: "1px solid rgba(255, 255, 255, 0.34)",
        appText: "rgba(17, 24, 39, 0.48)",
        hintText: "rgba(17, 24, 39, 0.32)",
        buttonBg: "rgba(99, 102, 241, 0.18)",
        butt

export default function TitleBar({
  onClose,
  onSettingsClick,
  shortcutDisplay,
  theme,
  onThemeToggle,
}: TitleBarProps) {
  const [isCloseHovered, setIsCloseHovered] = useState(false);
  const isDark = theme === "dark";
  const colors = isDark
    ? {
        background: "rgba(255, 255, 255, 0.04)",
        border: "1px solid rgba(255, 255, 255, 0.08)",
        title: "rgba(255, 255, 255, 0.56)",
        shortcut: "rgba(255, 255, 255, 0.32)",
        icon: "rgba(255, 255, 255, 0.42)",
        iconHover: "rgba(255, 255, 255, 0.82)",
        iconHoverBg: "rgba(255, 255, 255, 0.06)",
        trafficIdle: "rgba(255, 255, 255, 0.1)",
      }
    : {
        background: "rgba(255, 255, 255, 0.1)",
        border: "1px solid rgba(255, 255, 255, 0.38)",
        title: "rgba(17, 24, 39, 0.62)",
        shortcut: "rgba(17, 24, 39, 0.34)",
        icon: "rgba(17, 24, 39, 0.46)",
        iconHover: "rgba(17, 24, 39, 0.9)",
        iconHoverBg: "rgba(255, 255, 255, 0.28)",
        trafficId

export default function VimEditor({ onCopy, onModeChange, theme }: VimEditorProps) {
  const editorRef = useRef<HTMLDivElement>(null);
  const viewRef = useRef<EditorView | null>(null);

  const handleCopy = useCallback((text: string) => {
    onCopy(text);
  }, [onCopy]);

  const hasVimState = (cm: ReturnType<typeof getCM>): cm is CodeMirrorV => {
    return Boolean(cm?.state?.vim);
  };

  useEffect(() => {
    if (!editorRef.current) return;

    // Define :w and :wq commands for copy
    Vim.defineEx("write", "w", function () {
      if (viewRef.current) {
        const text = viewRef.current.state.doc.toString();
        handleCopy(text);
      }
    });

    Vim.defineEx("quit", "q", function () {
      if (viewRef.current) {
        // Clear and hide
        viewRef.current.dispatch({
          changes: { from: 0, to: viewRef.current.state.doc.length, insert: "" },
        });
        // Invoke Tauri hide
        import("@tauri-apps/api/core").then(({ invoke }) => {
          i

fn main() {
    tauri_build::build()
}

    fn default() -> Self {
        Self {
            shortcut: DEFAULT_SHORTCUT.to_string(),
            window_bounds: None,
            hide_menu_bar_icon: false,
            hide_dock_icon: false,
        }
    }

fn settings_path(app: &AppHandle) -> PathBuf {
    let dir = app
        .path()
        .app_config_dir()
        .unwrap_or_else(|_| PathBuf::from("."));
    fs::create_dir_all(&dir).ok();
    dir.join("settings.json")
}

fn load_settings(app: &AppHandle) -> AppSettings {
    let path = settings_path(app);
    if path.exists() {
        if let Ok(data) = fs::read_to_string(&path) {
            if let Ok(settings) = serde_json::from_str::<AppSettings>(&data) {
                return settings;
            }
        }
    }
    AppSettings::default()
}

fn save_settings(app: &AppHandle, settings: &AppSettings) {
    let path = settings_path(app);
    if let Ok(data) = serde_json::to_string_pretty(settings) {
        fs::write(path, data).ok();
    }
}

fn parse_modifiers(s: &str) -> Modifiers {
    let mut mods = Modifiers::empty();
    for part in s.split('+') {
        match part.trim() {
            "Alt" => mods |= Modifiers::ALT,
            "Shift" => mods |= Modifiers::SHIFT,
            "Control" => mods |= Modifiers::CONTROL,
            "Meta" | "Cmd" | "Super" => mods |= Modifiers::META,
            _ => {}
        }
    }
    mods
}

fn parse_code(s: &str) -> Option<Code> {
    let key_part = s.split('+').last()?.trim();
    let code = match key_part {
        "Space" => Code::Space,
        "Enter" => Code::Enter,
        "Tab" => Code::Tab,
        "Escape" => Code::Escape,
        "Backspace" => Code::Backspace,
        "Delete" => Code::Delete,
        "Up" => Code::ArrowUp,
        "Down" => Code::ArrowDown,
        "Left" => Code::ArrowLeft,
        "Right" => Code::ArrowRight,
        "Home" => Code::Home,
        "End" => Code::End,
        "PageUp" => Code::PageUp,
        "PageDown" => Code::PageDown,
        "Insert" => Code::Insert,
        "F1" => Code::F1,
        "F2" => Code::F2,
        "F3" => Code::F3,
        "F4" => Code::F4,
        "F5" => Code::F5,
        "F6" => Code::F6,
        "F7" => Code::F7,
        "F8" => Code::F8,
        "F9" => Code::F9,
        "F10" => Code::F10,
        "F11" => Code::F11,
        "F12" => Code::F12,
        "A" => Code::KeyA,
        "B" => Code::KeyB,
    

fn parse_shortcut(s: &str) -> Option<Shortcut> {
    let mods = parse_modifiers(s);
    let code = parse_code(s)?;
    let mods_opt = if mods.is_empty() { None } else { Some(mods) };
    Some(Shortcut::new(mods_opt, code))
}

fn apply_saved_window_bounds(app: &AppHandle) {
    let settings = load_settings(app);

    if let (Some(window), Some(bounds)) = (app.get_webview_window("main"), settings.window_bounds) {
        let _ = window.set_size(Size::Physical(PhysicalSize::new(
            bounds.width,
            bounds.height,
        )));
        let _ = window.set_position(Position::Physical(PhysicalPosition::new(
            bounds.x, bounds.y,
        )));
    }
}

fn persist_window_bounds(app: &AppHandle) {
    if let Some(window) = app.get_webview_window("main") {
        let Ok(position) = window.outer_position() else {
            return;
        };
        let Ok(size) = window.inner_size() else {
            return;
        };

        let mut settings = load_settings(app);
        settings.window_bounds = Some(WindowBounds {
            x: position.x,
            y: position.y,
            width: size.width,
            height: size.height,
        });
        save_settings(app, &settings);
    }
}

fn toggle_window(app: &AppHandle) {
    if let Some(window) = app.get_webview_window("main") {
        if window.is_visible().unwrap_or(false) {
            let _ = window.hide();
        } else {
            if load_settings(app).window_bounds.is_some() {
                apply_saved_window_bounds(app);
            } else {
                let _ = window.center();
            }
            let _ = window.show();
            let _ = window.set_focus();
            let _ = window.emit("window-shown", ());
        }
    }
}

fn show_window(app: &AppHandle) {
    if let Some(window) = app.get_webview_window("main") {
        if load_settings(app).window_bounds.is_some() {
            apply_saved_window_bounds(app);
        } else {
            let _ = window.center();
        }
        let _ = window.show();
        let _ = window.set_focus();
        let _ = window.emit("window-shown", ());
    }
}

fn hide_window_inner(app: &AppHandle) {
    if let Some(window) = app.get_webview_window("main") {
        let _ = window.hide();
    }
}

fn current_visibility_settings(app: &AppHandle) -> VisibilitySettings {
    let settings = load_settings(app);
    VisibilitySettings {
        hide_menu_bar_icon: settings.hide_menu_bar_icon,
    }
}

fn apply_visibility_settings(app: &AppHandle, settings: &AppSettings) {
    if let Some(tray) = app.tray_by_id(TRAY_ID) {
        let _ = tray.set_visible(!settings.hide_menu_bar_icon);
    }

    #[cfg(target_os = "macos")]
    {
        let _ = settings;
        let _ = app.set_activation_policy(ActivationPolicy::Accessory);
    }
}

fn hide_window(app: AppHandle) {
    hide_window_inner(&app);
}

fn show_main_window(app: AppHandle) {
    show_window(&app);
}

fn get_shortcut(app: AppHandle) -> String {
    let settings = load_settings(&app);
    settings.shortcut
}

fn get_visibility_settings(app: AppHandle) -> VisibilitySettings {
    current_visibility_settings(&app)
}

fn update_shortcut(
    app: AppHandle,
    shortcut: String,
    state: tauri::State<'_, ShortcutState_>,
) -> Result<(), String> {
    // Parse the new shortcut
    let new_sc = parse_shortcut(&shortcut).ok_or("Invalid shortcut format")?;

    // Unregister old shortcut
    let old_shortcut_str = {
        let guard = state.current.lock().map_err(|e| e.to_string())?;
        guard.clone()
    };
    if let Some(old_sc) = parse_shortcut(&old_shortcut_str) {
        app.global_shortcut().unregister(old_sc).ok();
    }

    // Register new shortcut
    app.global_shortcut()
        .on_shortcut(new_sc, |app, _shortcut, event| {
            if event.state == ShortcutState::Pressed {
                toggle_window(app);
            }
        })
        .map_err(|e| format!("Failed to register shortcut: {}", e))?;

    // Save to settings
    let mut settings = load_settings(&app);
    settings.shortcut = shortcut.clone();
    save_settings(&app, &settings);

    // Update state
    {
     

fn update_visibility_settings(
    app: AppHandle,
    hide_menu_bar_icon: bool,
) {
    let mut settings = load_settings(&app);
    settings.hide_menu_bar_icon = hide_menu_bar_icon;
    settings.hide_dock_icon = true;
    save_settings(&app, &settings);
    apply_visibility_settings(&app, &settings);
}

pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_clipboard_manager::init())
        .plugin(tauri_plugin_liquid_glass::init())
        .plugin(tauri_plugin_shell::init())
        .plugin(
            tauri_plugin_global_shortcut::Builder::new()
                .with_handler(|_app, _shortcut, _event| {
                    // Handler is set per-shortcut via on_shortcut, this is a no-op fallback
                })
                .build(),
        )
        .manage(ShortcutState_ {
            current: Mutex::new(DEFAULT_SHORTCUT.to_string()),
        })
        .setup(|app| {
            // Setup logging in debug mode
            if cfg!(debug_assertions) {
                app.handle().plugin(
                    tauri_plugin_log::Builder::default()
                        .level(log::LevelFilter::Info)
                        .build(),
                )?;
            }

            // Load saved settings
            let settings = load_settings(app.handle());
  

fn main() {
    app_lib::run();
}