A!leys Galerie

"""
MemoMaster - Intelligent Note-Taking API
Features:
- Text analysis with NLP (sentiment, key terms)
- Note organization with automatic tagging
- Search by content and metadata
- Export to Markdown/PDF
"""

from typing import List, Dict, Optional
from datetime import datetime, timedelta
import uuid
import re
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel
from starlette.responses import JSONResponse
import textstat
import nltk
from nltk.sentiment import SentimentIntensityAnalyzer
from fastapi.middleware.cors import CORSMiddleware

# Download NLTK resources
try:
    nltk.data.find('tokenizers/punkt')
    nltk.data.find('sentiment/vader_lexicon')
except LookupError:
    nltk.download('punkt')
    nltk.download('vader_lexicon')

app = FastAPI(
    title="MemoMaster API",
    description="Intelligent Note-Taking API with NLP Features",
    version="1.0.0"
)

# CORS configuration
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

class Note(BaseModel):
    title: str
    content: str
    tags: List[str] = []
    created_at: Optional[datetime] = None
    updated_at: Optional[datetime] = None
    is_important: bool = False

class NoteResponse(BaseModel):
    id: str
    title: str
    content: str
    tags: List[str]
    created_at: datetime
    updated_at: datetime
    is_important: bool
    sentiment_score: float
    reading_time: int  # in seconds
    key_terms: List[str]

class NoteAnalysis(BaseModel):
    sentiment: Dict[str, float]
    complexity: float
    reading_time: int
    key_terms: List[str]
    summary: str

# In-memory database (for demo purposes)
notes_db: Dict[str, Note] = {}

@app.post("/notes/", response_model=NoteResponse)
async def create_note(note: Note):
    """Create a new note with automatic analysis"""
    note_id = str(uuid.uuid4())
    note.created_at = datetime.utcnow()
    note.updated_at = note.created_at

    # Store note
    notes_db[note_id] = note

    # Return with analysis
    return await analyze_note(note_id)

@app.get("/notes/{note_id}", response_model=NoteResponse)
async def read_note(note_id: str):
    """Read a note with analysis"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")
    return await analyze_note(note_id)

@app.get("/notes/", response_model=List[NoteResponse])
async def list_notes(
    tags: Optional[List[str]] = None,
    search: Optional[str] = None,
    limit: int = 10,
    important: Optional[bool] = None
):
    """List notes with optional filtering"""
    filtered_notes = []

    for note in notes_db.values():
        # Filter by tags
        if tags:
            if not any(tag in note.tags for tag in tags):
                continue

        # Filter by importance
        if important is not None:
            if note.is_important != important:
                continue

        # Filter by search term
        if search:
            if (search.lower() not in note.title.lower() and
                search.lower() not in note.content.lower()):
                continue

        filtered_notes.append(note)

    # Apply limit
    filtered_notes = filtered_notes[:limit]

    # Return with analysis
    return [await analyze_note(note_id) for note_id, note in notes_db.items() if note in filtered_notes]

@app.put("/notes/{note_id}", response_model=NoteResponse)
async def update_note(note_id: str, note: Note):
    """Update an existing note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    note.updated_at = datetime.utcnow()
    notes_db[note_id] = note
    return await analyze_note(note_id)

@app.delete("/notes/{note_id}")
async def delete_note(note_id: str):
    """Delete a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    del notes_db[note_id]
    return JSONResponse(status_code=status.HTTP_204_NO_CONTENT)

@app.post("/notes/{note_id}/tag", response_model=NoteResponse)
async def add_tag(note_id: str, tag: str):
    """Add a tag to a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    if tag in notes_db[note_id].tags:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Tag already exists")

    notes_db[note_id].tags.append(tag)
    notes_db[note_id].updated_at = datetime.utcnow()
    return await analyze_note(note_id)

@app.post("/notes/{note_id}/importance", response_model=NoteResponse)
async def toggle_importance(note_id: str):
    """Toggle importance flag on a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    notes_db[note_id].is_important = not notes_db[note_id].is_important
    notes_db[note_id].updated_at = datetime.utcnow()
    return await analyze_note(note_id)

async def analyze_note(note_id: str) -> NoteResponse:
    """Analyze a note and return enhanced response"""
    note = notes_db[note_id]

    # Sentiment analysis
    sia = SentimentIntensityAnalyzer()
    sentiment = sia.polarity_scores(note.content)
    compound_score = sentiment['compound']

    # Text complexity
    complexity = textstat.flesch_reading_ease(note.content)

    # Reading time (words per minute is typically 200)
    word_count = len(re.findall(r'\w+', note.content))
    reading_time = int((word_count / 200) * 60)  # Convert to seconds

    # Extract key terms (simple approach)
    key_terms = [term for term in nltk.word_tokenize(note.title.lower()) if len(term) > 3]

    # Generate summary (very basic)
    summary = f"Note about {note.title} with {len(key_terms)} key terms."

    return NoteResponse(
        id=note_id,
        title=note.title,
        content=note.content,
        tags=note.tags,
        created_at=note.created_at,
        updated_at=note.updated_at,
        is_important=note.is_important,
        sentiment_score=compound_score,
        reading_time=reading_time,
        key_terms=key_terms
    )

@app.get("/notes/analysis/{note_id}", response_model=NoteAnalysis)
async def get_note_analysis(note_id: str):
    """Get detailed analysis of a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    note = notes_db[note_id]

    # Sentiment analysis
    sia = SentimentIntensityAnalyzer()
    sentiment = sia.polarity_scores(note.content)

    # Text complexity
    complexity = textstat.flesch_reading_ease(note.content)

    # Reading time
    word_count = len(re.findall(r'\w+', note.content))
    reading_time = int((word_count / 200) * 60)  # Convert to seconds

    # Extract key terms
    key_terms = [term for term in nltk.word_tokenize(note.title.lower()) if len(term) > 3]

    # Generate summary (very basic)
    summary = f"Note about {note.title} with {len(key_terms)} key terms."

    return NoteAnalysis(
        sentiment=sentiment,
        complexity=complexity,
        reading_time=reading_time,
        key_terms=key_terms,
        summary=summary
    )

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

use wasm_bindgen::prelude::*;
use js_sys::{
    Array, Reflect, Object, Undefinable, Uint8Array, console,
};
use web_sys::{
    window, local_storage, HttpRequest, HttpRequestResponse, FetchOptions, RequestInit,
    RequestCache, RequestCredentials, RequestMode, RequestReferrerPolicy, RequestDestination,
};
use serde::{Serialize, Deserialize};
use std::error::Error;
use wasm_bindgen_futures::JsFuture;

// Custom highlight pattern that includes colors and fonts
const HIGHLIGHT_PATTERN: &str = r#"
    background: #FFD700;
    color: #000000;
    font-weight: bold;
    padding: 0 2px;
    border-radius: 2px;
    white-space: pre-wrap;
"#;

// Configuration struct with Serialize/Deserialize
#[derive(Serialize, Deserialize, Debug)]
struct Config {
    highlight_color: String,
    history_limit: usize,
    search_history: Vec<String>,
}

impl Default for Config {
    fn default() -> Self {
        Config {
            highlight_color: "#FFD700".to_string(),
            history_limit: 10,
            search_history: Vec::new(),
        }
    }
}

// Load or initialize config from localStorage
fn load_config() -> Config {
    if let Some(storage) = window().and_then(|w| w.local_storage()) {
        if let Ok(Some(config_json)) = JsFuture::from(storage.get("aileygrep_config")) {
            if let Ok(Some(config_string)) = config_json.dyn_into::<String>() {
                if let Ok(config) = serde_json::from_str(&config_string) {
                    return config;
                }
            }
        }
    }
    Config::default()
}

// Save config to localStorage
fn save_config(config: &Config) -> Result<(), JsValue> {
    if let Some(storage) = window().and_then(|w| w.local_storage()) {
        let config_json = serde_json::to_string(config)?;
        storage.set("aileygrep_config", &config_json)?;
    }
    Ok(())
}

// Apply highlight to matches
fn apply_highlight(matches: Vec<(usize, usize)>) -> String {
    let mut result = String::new();
    let mut last_pos = 0;
    for (start, end) in matches {
        result.push_str(&js_sys::Reflect::get(&result, &last_pos.to_string()).unwrap_or(&JsvValue::UNDEFINED));
        result.push_str("<span style=\"");
        result.push_str(HIGHLIGHT_PATTERN);
        result.push_str("\">");
        if let Some(text) = js_sys::Reflect::get(&result, &end.to_string()).unwrap_or(&JsvValue::UNDEFINED).dyn_into::<String>().ok() {
            result.push_str(&text);
        }
        result.push_str("</span>");
        last_pos = end + 1;
    }
    result.push_str(&js_sys::Reflect::get(&result, &last_pos.to_string()).unwrap_or(&JsvValue::UNDEFINED));
    result
}

// Search files using fetch (simulated file system)
async fn search_files(query: &str) -> Result<String, JsValue> {
    // Simulate a file system with a fetch request
    let mut opts = FetchOptions::new();
    opts.method("GET");
    let request = RequestInit::new_with_str(&format!("/api/search?query={}", query))?;
    let response = window().fetch_with_request_and_init(&request, &opts).await?;

    if response.status() == 200 {
        let text = JsFuture::from(response.text()).await?;
        Ok(text)
    } else {
        Err(JsValue::from_str(&format!("HTTP error {}!", response.status())))
    }
}

// Main function with WebAssembly entry point
#[wasm_bindgen(start)]
pub async fn main() -> Result<(), JsValue> {
    console::log_1(&"AileyGrep: Search tool started".into());

    // Load configuration
    let mut config = load_config();

    // Simulate user input (in a real app, this would be from UI)
    let search_terms = ["main.rs", "pub mod", "AileyGrep"];

    for term in search_terms {
        // Search files
        match search_files(&term).await {
            Ok(result) => {
                console::log_1(&format!("Search results for '{}':", term).into());
                console::log_1(&result.into());
                // Apply highlighting
                let highlighted = apply_highlight(vec![(0, term.len())]);
                console::log_1(&format!("Highlighted results: {}", highlighted).into());

                // Update search history
                if !config.search_history.contains(&term.to_string()) {
                    config.search_history.push(term.to_string());
                    if config.search_history.len() > config.history_limit {
                        config.search_history.remove(0);
                    }
                    save_config(&config)?;
                }
            }
            Err(e) => console::log_1(&e),
        }
    }

    // Final status log
    console::log_1(&format!("AileyGrep: Saved {} search terms to localStorage", config.search_history.len()).into());

    Ok(())
}

import SwiftUI
import Combine

struct ZenGridGallery: View {
    // MARK: - State
    @State private var images: [Image] = []
    @State private var selectedImageIndex: Int? = nil
    @State private var isEditing: Bool = false
    @State private var photoLibraryPermission: Bool = false
    @State private var showZoomedImage: Bool = false

    // MARK: - Preview Images
    private let previewImages: [Image] = [
        Image("tate1"),
        Image("tate2"),
        Image("tate3")
    ]

    // MARK: - Body
    var body: some View {
        NavigationStack {
            ZStack {
                // Background
                RadialGradient(
                    gradient: Gradient(colors: [.clear, .black.opacity(0.3)]),
                    center: .center,
                    startRadius: 0,
                    endRadius: 200
                )
                .ignoresSafeArea()

                // Main View
                ScrollView {
                    LazyVGrid(columns: [GridItem(.adaptive(minimum: 200), spacing: 10)],
                              spacing: 10) {
                        ForEach(images.indices, id: \.self) { index in
                            ImageView(image: images[index], selected: selectedImageIndex == index)
                                .onTapGesture {
                                    selectedImageIndex = index
                                    isEditing = true
                                }
                        }
                    }
                    .padding()

                    // Edit Button
                    Button(action: {
                        isEditing = true
                    }) {
                        Label("Edit", systemImage: "pencil")
                            .font(.headline)
                            .foregroundColor(.primary)
                    }
                    .padding(.top, 20)
                }
                .background(Color.clear)

                // Zoomed Image Overlay
                if showZoomedImage && let index = selectedImageIndex {
                    ZStack {
                        Color.black.opacity(0.9)
                            .ignoresSafeArea()
                            .onTapGesture {
                                withAnimation {
                                    showZoomedImage = false
                                }
                            }

                        Image(images[index].name ?? "")
                            .resizable()
                            .scaledToFit()
                            .frame(maxWidth: .infinity, maxHeight: .infinity)
                            .transition(.opacity)
                    }
                    .zIndex(1)
                }
            }
            .navigationTitle("Zen Grid")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: {
                        addImage()
                    }) {
                        Label("Add", systemImage: "plus")
                    }
                }
            }
            .onAppear {
                checkPhotoLibraryPermission()
                if images.isEmpty {
                    images = previewImages
                }
            }
            .sheet(isPresented: $isEditing) {
                ImageEditor(image: $images[selectedImageIndex ?? 0])
            }
        }
    }

    // MARK: - Functions
    private func addImage() {
        if !photoLibraryPermission {
            return
        }

        let picker = UIImagePickerController()
        picker.delegate = self
        UIApplication.shared.windows.first?.rootViewController?.present(picker, animated: true)
    }

    private func checkPhotoLibraryPermission() {
        let status = PHPhotoLibrary.authorizationStatus()
        if status == .notDetermined {
            PHPhotoLibrary.requestAuthorization { granted in
                DispatchQueue.main.async {
                    photoLibraryPermission = granted
                }
            }
        } else {
            photoLibraryPermission = status == .authorized
        }
    }
}

// MARK: - Image View
struct ImageView: View {
    let image: Image
    let selected: Bool

    var body: some View {
        ZStack {
            RoundedRectangle(cornerRadius: 8)
                .stroke(selected ? Color.accentColor : Color.clear, lineWidth: 2)

            image
                .resizable()
                .scaledToFill()
                .frame(height: 200)
                .clipped()
                .opacity(selected ? 1 : 0.9)
        }
        .frame(height: 200)
    }
}

// MARK: - Image Editor
struct ImageEditor: View {
    @Binding var image: Image

    @State private var zoomScale: CGFloat = 1.0
    @State private var panOffset: CGSize = .zero

    var body: some View {
        VStack {
            // Image View
            GeometryReader { geometry in
                Image(image)
                    .resizable()
                    .scaledToFit()
                    .frame(width: geometry.size.width, height: geometry.size.height)
                    .offset(x: panOffset.width, y: panOffset.height)
                    .scaleEffect(zoomScale)
                    .gesture(
                        MagnificationGesture()
                            .onChanged { value in
                                zoomScale = value.magnification
                            }
                    )
                    .gesture(
                        DragGesture()
                            .onChanged { value in
                                panOffset = value.translation
                            }
                            .onEnded { _ in
                                panOffset = .zero
                            }
                    )
            }
            .frame(height: 300)
            .padding(.horizontal)

            // Save Button
            Button(action: {
                UIApplication.shared.windows.first?.rootViewController?.dismiss(animated: true)
            }) {
                Text("Done")
                    .font(.headline)
                    .foregroundColor(.white)
                    .frame(width: 200, height: 44)
                    .background(Color.accentColor)
                    .cornerRadius(8)
            }
            .padding(.top)
        }
        .background(Color.black)
        .ignoresSafeArea()
    }
}

// MARK: - Preview Provider
struct ZenGridGallery_Previews: PreviewProvider {
    static var previews: some View {
        ZenGridGallery()
            .preferredColorScheme(.dark)
    }
}

// MARK: - UIImagePickerController Delegate
extension ZenGridGallery: UINavigationControllerDelegate, UIImagePickerControllerDelegate {
    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
        if let uiImage = info[.originalImage] as? UIImage {
            let swiftUIImage = Image(uiImage: uiImage)
            images.append(swiftUIImage)
        }
        picker.dismiss(animated: true)
    }
}

// MARK: - Preview Images
struct PreviewImage: View {
    var body: some View {
        Image(systemName: "photo")
            .resizable()
            .scaledToFill()
            .frame(width: 200, height: 200)
            .clipped()
            .opacity(0.5)
    }
}

use serde_json::{Value, from_reader, to_writer, ser::PrettyGenerator};
use std::io::{self, Read, Write};
use std::error::Error;
use rand::Rng;
use crossterm::{
    execute,
    style::{Color, Print, SetForegroundColor},
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
    cursor::Hide, queue,
    Event, KeyCode,
};
use ratatui::{
    backend::CrosstermBackend,
    Terminal,
    text::{Span, Text},
    widgets::{Block, Borders, Paragraph},
    layout::{Constraint, Direction, Layout, Rectangle},
    style::{Style, Stylize},
};
use std::time::Duration;

const CONFETTI_CHARS: [char; 12] = ['♥', '☆', '★', '♦', '♣', '♠', '•', '◕', '◈', '◑', '☺', '☻'];
const COLORS: [Color; 8] = [
    Color::Red,
    Color::Green,
    Color::Yellow,
    Color::Blue,
    Color::Magenta,
    Color::Cyan,
    Color::White,
    Color::Gray,
];

struct JSONFormatter {
    terminal: Terminal<CrosstermBackend>,
    confetti_active: bool,
    confetti_timeout: Duration,
}

impl JSONFormatter {
    fn new(terminal: Terminal<CrosstermBackend>) -> Self {
        JSONFormatter {
            terminal,
            confetti_active: false,
            confetti_timeout: Duration::from_millis(100),
        }
    }

    fn handle_confetti(&mut self) {
        if !self.confetti_active {
            return;
        }

        let width = self.terminal.size().unwrap().width as usize;
        let height = self.terminal.size().unwrap().height as usize;

        let mut rng = rand::thread_rng();
        let mut confetti_lines = Vec::new();

        for _ in 0..(rng.gen_range(5..15)) {
            let char_index = rng.gen_range(0..CONFETTI_CHARS.len());
            let color_index = rng.gen_range(0..COLORS.len());
            let x = rng.gen_range(0..width);
            let y = rng.gen_range(0..height);
            let speed = rng.gen_range(1..4);
            let char_span = Span::from(CONFETTI_CHARS[char_index].to_string())
                .fg(COLORS[color_index])
                .bold();
            confetti_lines.push((x, y, speed, char_span));
        }

        self.draw_confetti(confetti_lines);
        if self.confetti_active {
            std::thread::spawn(|| {
                std::thread::sleep(self.confetti_timeout);
                let mut term = self.terminal.clone();
                term.clear().unwrap();
                term.draw(|f| {
                    f.render_widget(
                        Paragraph::new("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n")
                            .block(Block::default().borders(Borders::NONE))
                            .style(Style::default().add_modifier(ratatui::style::Modifier::REVERSED)),
                        f.size(),
                    );
                }).unwrap();
            });
        }
    }

    fn draw_confetti(&mut self, lines: Vec<(usize, usize, usize, Span)>) {
        let mut term = self.terminal.clone();
        term.clear().unwrap();
        term.draw(|f| {
            for (x, y, speed, char_span) in lines {
                let mut y_pos = y;
                for _ in 0..speed {
                    if y_pos > 0 {
                        y_pos -= 1;
                    } else {
                        break;
                    }
                }
                if y_pos < f.size().height as usize {
                    let position = (x, y_pos);
                    f.render_widget(
                        Paragraph::new(char_span)
                            .block(Block::default().borders(Borders::NONE))
                            .position(position),
                        f.size(),
                    );
                }
            }
        }).unwrap();
    }

    fn format_json(&mut self, input: String) -> Result<String, Box<dyn Error>> {
        let value: Value = from_reader(&mut io::Cursor::new(input.clone()))?;
        let mut pretty = PrettyGenerator::new(io::stdout());
        to_writer(&mut pretty, &value)?;

        let output = prettyIntoString(&value)?;

        if output.len() > 500 {
            self.confetti_active = true;
            self.handle_confetti();
        }

        Ok(output)
    }
}

fn prettyIntoString(value: &Value) -> Result<String, Box<dyn Error>> {
    let mut buffer = String::new();
    let mut generator = PrettyGenerator::new(&mut buffer);
    generator.write(value)?;
    Ok(buffer)
}

fn main() -> Result<(), Box<dyn Error>> {
    // Initialize terminal
    let mut stdout = io::stdout();
    enable_raw_mode()?;
    let mut terminal = Terminal::new(CrosstermBackend::new(stdout))?;
    execute!(
        terminal.backend_mut(),
        EnterAlternateScreen,
        Hide,
    )?;
    terminal.clear()?;

    let mut formatter = JSONFormatter::new(terminal);

    // Main loop
    loop {
        // Draw UI
        let size = terminal.size()?;
        let layout = Layout::default()
            .direction(Direction::Vertical)
            .constraints([
                Constraint::Percentage(20),
                Constraint::Percentage(60),
                Constraint::Percentage(20),
            ])
            .split(size);

        terminal.draw(|f| {
            // Header
            let header = Text::from("GlitterJSON - JSON Pretty Printer with Syntax Highlighting")
                .green()
                .bold();
            f.render_widget(
                Paragraph::new(header)
                    .block(Block::default().borders(Borders::ALL).title("GlitterJSON")),
                layout[0],
            );

            // Instructions
            let instructions = Text::from([
                "1. Paste your JSON (max 500 chars for confetti!)",
                "2. Press Enter to format",
                "3. Press Esc to quit",
                "4. Press Backspace to clear",
            ])
            .green()
            .bold();
            f.render_widget(
                Paragraph::new(instructions)
                    .block(Block::default().borders(Borders::ALL).title("Instructions")),
                layout[2],
            );
        })?;

        // Get user input
        let mut input = String::new();
        let event = terminal.backend().poll_event()?;
        match event.code {
            KeyCode::Char(c) if c.is_ascii() => {
                input.push(c);
                let mut term = formatter.terminal.clone();
                term.draw(|f| {
                    let output = Text::from(input.clone()).green();
                    f.render_widget(
                        Paragraph::new(output)
                            .block(Block::default().borders(Borders::ALL).title("Input")),
                        layout[1],
                    );
                })?;
            }
            KeyCode::Backspace => {
                input.pop();
                let mut term = formatter.terminal.clone();
                term.draw(|f| {
                    let output = Text::from(input.clone()).green();
                    f.render_widget(
                        Paragraph::new(output)
                            .block(Block::default().borders(Borders::ALL).title("Input")),
                        layout[1],
                    );
                })?;
            }
            KeyCode::Enter => {
                if input.trim().is_empty() {
                    continue;
                }
                match formatter.format_json(input.clone()) {
                    Ok(output) => {
                        // Display formatted JSON
                        let mut term = formatter.terminal.clone();
                        term.draw(|f| {
                            let formatted = Text::from(output.clone())
                                .green()
                                .bold();
                            f.render_widget(
                                Paragraph::new(formatted)
                                    .block(Block::default().borders(Borders::ALL).title("Formatted JSON")),
                                layout[1],
                            );
                        })?;
                    }
                    Err(e) => {
                        // Display error
                        let mut term = formatter.terminal.clone();
                        term.draw(|f| {
                            let error = Text::from(format!("Error: {}", e))
                                .red()
                                .bold();
                            f.render_widget(
                                Paragraph::new(error)
                                    .block(Block::default().borders(Borders::ALL).title("Error")),
                                layout[1],
                            );
                        })?;
                    }
                }
            }
            KeyCode::Esc => break,
            _ => {}
        }
    }

    // Cleanup
    execute!(
        terminal.backend_mut(),
        LeaveAlternateScreen,
        Hide,
    )?;
    disable_raw_mode()?;
    terminal.show_cursor()?;
    Ok(())
}