A!ley's Gallery

use rand::{Rng, thread_rng};
use std::io::{self, Write};
use std::time::Instant;

// --- Konstanten ---
const MIN_LENGTH: usize = 8;
const MAX_LENGTH: usize = 64;
const CHAR_SET: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+=-{}[]|\\:;\"'<>,.?/";

// --- Datenstrukturen ---
struct PasswordStrength {
    entropy: f64,
    score: u8,
    description: String,
}

// --- Funktionen ---

/// Berechnet die Entropie eines Passworts basierend auf der Länge und der Größe des Zeichensatzes.
/// Formel: E = L * log2(N)
fn calculate_entropy(password: &str) -> f64 {
    let n = CHAR_SET.len() as f64;
    let l = password.len() as f64;
    l * n.log2()
}

/// Bewertet die Stärke eines Passworts basierend auf Entropie und Länge.
fn evaluate_strength(password: &str) -> PasswordStrength {
    let entropy = calculate_entropy(password);
    let score = if entropy < 40.0 {
        1
    } else if entropy < 60.0 {
        2
    } else if entropy < 80.0 {
        3
    } else {
        4
    };

    let description = match score {
        1 => "Schwach - leicht zu knacken.",
        2 => "Mittel - brauchst du für weniger kritische Dinge.",
        3 => "Stark - gut für die meisten Konten.",
        4 => "Sehr stark - fast unknackbar.",
        _ => "Unbekannt.",
    };

    PasswordStrength {
        entropy,
        score,
        description: description.to_string(),
    }
}

/// Generiert ein zufälliges Passwort.
fn generate_password(length: usize) -> String {
    let mut rng = thread_rng();
    let mut password = String::with_capacity(length);
    for _ in 0..length {
        let idx = rng.gen_range(0..CHAR_SET.len());
        password.push(CHAR_SET.chars().nth(idx).unwrap());
    }
    password
}

/// Zeigt eine kleine ASCII-Animation als "Sound-Feedback".
fn play_feedback(score: u8) {
    let frames = [
        " [ ] ",
        " [###] ",
        " [###] ",
        " [ ] ",
    ];
    for i in 0..4 {
        print!("\r{}", frames[i]);
        std::io::Write::flush(&mut io::stdout()).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
    println!("\n");
}

// --- Main ---

fn main() {
    println!("--- PassGen Entropy Analyzer ---");
    println!("Generiere ein sicheres Passwort (8-64 Zeichen):");

    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Fehler beim Lesen");
    let length: usize = input.trim().parse().unwrap_or(16);

    if length < MIN_LENGTH || length > MAX_LENGTH {
        println!("Bitte gib eine Länge zwischen {} und {} ein.", MIN_LENGTH, MAX_LENGTH);
        return;
    }

    let start = Instant::now();
    let password = generate_password(length);
    let duration = start.elapsed();

    let strength = evaluate_strength(&password);

    println!("Generiertes Passwort: {}", password);
    println!("Entropie: {:.2} bits", strength.entropy);
    println!("Bewertung: {}/4 - {}", strength.score, strength.description);
    println!("Generiert in: {:?}", duration);

    play_feedback(strength.score);
}

using UnityEngine;
using System.Collections.Generic;

public class FoggyMinimap : MonoBehaviour
{
    [Header("Minimap Settings")]
    [SerializeField] private Transform playerTransform;
    [SerializeField] private float viewDistance = 10f;
    [SerializeField] private float mapScale = 0.1f;
    [SerializeField] private Color fogColor = Color.black;
    [SerializeField] private Color revealedColor = Color.white;

    [Header("Grid Settings")]
    [SerializeField] private int gridWidth = 20;
    [SerializeField] private int gridHeight = 20;
    [SerializeField] private float cellSize = 1f;

    private Texture2D minimapTexture;
    private Color[] mapData;
    private Vector2 lastPlayerPosition;

    void Start()
    {
        InitializeMinimap();
    }

    void InitializeMinimap()
    {
        minimapTexture = new Texture2D(gridWidth, gridHeight);
        mapData = new Color[gridWidth * gridHeight];

        for (int i = 0; i < mapData.Length; i++)
        {
            mapData[i] = fogColor;
        }

        UpdateMinimap();
    }

    void Update()
    {
        if (playerTransform != null)
        {
            UpdateMinimap();
        }
    }

    void UpdateMinimap()
    {
        Vector3 currentPosition = playerTransform.position;
        Vector3 direction = currentPosition - lastPlayerPosition;

        for (int x = 0; x < gridWidth; x++)
        {
            for (int y = 0; y < gridHeight; y++)
            {
                Vector3 cellPosition = new Vector3(x * cellSize, y * cellSize, 0);
                float distance = Vector3.Distance(currentPosition, cellPosition);

                if (distance < viewDistance)
                {
                    mapData[x + y * gridWidth] = revealedColor;
                }
            }
        }

        minimapTexture.SetPixels(mapData);
        minimapTexture.Apply();
        lastPlayerPosition = currentPosition;
    }

    void OnDestroy()
    {
        if (minimapTexture != null)
        {
            Destroy(minimapTexture);
        }
    }
}

import android.app.Activity
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.*
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.*
import androidx.compose.ui.graphics.*
import androidx.compose.ui.text.*
import androidx.compose.ui.unit.*
import androidx.compose.ui.viewinterop.AndroidView
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.key
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyInteraction
import androidx.compose.ui.input.keyI
Hier ist der vollständige Code für den Bookmark Manager mit Retro-Pixel-Art-Stil:

using UnityEngine;
using System;
using System.Collections.Generic;
using System.Linq;

public class SoulBind : MonoBehaviour
{
 [Header("Input Configuration")]
 [SerializeField] private List bindings;

 private Dictionary<KeyCode, ActionBinding> keyToBindingMap = new Dictionary<KeyCode, ActionBinding>();

 public void Start()
 {
 foreach (var binding in bindings)
 keyToBindingMap[binding.DefaultKey] = binding;

 Debug.Log("SoulBind Initialized - Bindings Loaded.");
 }

 public void Update()
 {
 foreach (var binding in bindings)
 {
 if (Input.GetKeyDown(binding.DefaultKey))
 {
 ExecuteAction(binding);
 }
 }
 }

 private void ExecuteAction(ActionBinding binding)
 {
 Debug.Log($"Action {binding.ActionName} triggered!");
 // Hier die eigentliche Logik der Aktion ausführen (z.B. Jump, Shoot etc.)
 }

 public void Rebind(KeyCode newKey)
 {
 foreach (var binding in bindings)
 {
 if (Input.GetKeyDown(binding.DefaultKey)) // Test-Zuweisung
 {
 binding.DefaultKey = newKey;
 keyToBindingMap[newKey] = binding;
 Debug.Log($"Action {binding.ActionName} rebound to {newKey}");
 }
 }
 }

 public void ShowSkillTree()
 {
 Debug.Log("SoulBind Skill Tree:");
 foreach (var binding in bindings)
 {
 string status = binding.DefaultKey == KeyCode.Space ? "Unlocked (Default)" : "Locked";
 Debug.Log($"- {binding.ActionName}: {binding.DefaultKey} [{status}]");
 }
 }
}

[Serializable]
public class ActionBinding
{
 public string ActionName;
 public KeyCode DefaultKey;
 public float SoulExperience; // Der kreative Twist: Bindungen haben "Erfahrung"

 public ActionBinding(string name, KeyCode key)
 {
 ActionName = name;
 DefaultKey = key;
 SoulExperience = 0f;
 }

 public void EarnExperience(float amount)
 {
 SoulExperience += amount;
 if (SoulExperience >= 100)
 Debug.Log($"Action {ActionName} Soul Unlocked!");
 }
}

/* 
 Zusätzlicher Twist: Der Skill Tree visualisiert effiziente Bindungen. 
 Wenn der Spieler Aktionen mit effizienten Keys (z.B. WASD) kombiniert, 
 wird SoulExperience schneller generiert als bei unüblichen Bindungen.
*/

public class SoulBindSkillTree : MonoBehaviour
{
 public SoulBind soulBind;

 private void Start()
 {
 soulBind.ShowSkillTree();
 }

 public void SimulateUsage(string actionName)
 {
 var binding = soulBind.bindings.FirstOrDefault(b => b.ActionName == actionName);
 if (binding != null)
 {
 float experienceGain = binding.DefaultKey == KeyCode.Space ? 10f : 5f;
 binding.EarnExperience(experienceGain);
 }
 }
}

<!DOCTYPE html>
<html lang="en">

 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 NeonDeep Monitoring Station
 
 :root {
 --bg-color: #0a192f;
 --card-bg: rgba(255, 255, 255, 0.05);
 --accent-color: #64ffda;
 --text-color: #ccd6f6;
 --border-radius: 12px;
 --transition-speed: 0.4s;
 }

 [data-theme="light"] {
 --bg-color: #f0f4f8;
 --card-bg: rgba(255, 255, 255, 0.8);
 --accent-color: #1a73e8;
 --text-color: #2c3e50;
 }

 body {
 margin: 0;
 font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
 background-color: var(--bg-color);
 color: var(--text-color);
 transition: background-color var(--transition-speed) ease;
 display: flex;
 justify-content: center;
 align-items: center;
 height: 100vh;
 }

 .dashboard {
 width: 90%;
 max-width: 1200px;
 display: grid;
 grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
 gap: 2rem;
 padding: 2rem;
 }

 .card {
 background-color: var(--card-bg);
 border: 1px solid rgba(255, 255, 255, 0.1);
 border-radius: var(--border-radius);
 padding: 2rem;
 box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 transition: transform var(--transition-speed) ease;
 }

 .card:hover {
 transform: translateY(-5px);
 }

 .header {
 display: flex;
 justify-content: space-between;
 align-items: center;
 margin-bottom: 2rem;
 }

 .title {
 font-size: 1.5rem;
 font-weight: bold;
 }

 .theme-toggle {
 background: var(--accent-color);
 border: none;
 padding: 0.5rem 1rem;
 border-radius: 20px;
 cursor: pointer;
 font-weight: bold;
 transition: opacity var(--transition-speed) ease;
 }

 .theme-toggle:hover {
 opacity: 0.8;
 }

 .chart-container {
 width: 100%;
 height: 250px;
 }

 .metric {
 display: flex;
 justify-content: space-between;
 margin-bottom: 1rem;
 }

 .metric span {
 font-size: 0.9rem;
 }

 .metric strong {
 font-size: 1.2rem;
 }

 svg {
 width: 100%;
 height: 100%;
 }

 .bar {
 fill: var(--accent-color);
 transition: height 0.5s ease;
 }

 @media (max-width: 600px) {
 .dashboard {
 grid-template-columns: 1fr;
 }
 }
 

<div class="dashboard">
 <header class="header">
 <h1 class="title">NeonDeep Monitoring
 <button id="themeToggle" class="theme-toggle">Toggle Theme
 

 <div class="card">
 Performance Metrics
 <div id="metricsContainer">
 

 <div class="card">
 Real-time Data
 <div class="chart-container">
 <svg id="liveChart" viewBox="0 0 400 250">
 <rect id="bar1" class="bar" x="40" y="250" width="30" height="0">
 <rect id="bar2" class="bar" x="120" y="250" width="30" height="0">
 <rect id="bar3" class="bar" x="200" y="250" width="30" height="0">
 <rect id="bar4" class="bar" x="280" y="250" width="30" height="0">
 
 
 

 <div class="card">
 System Status
 All systems operational. Monitoring active.
 <div id="statusIndicator" style="display: inline-block; width: 12px; height: 12px; border-radius: 50%; background-color: var(--accent-color);">
 

 const themeToggle = document.getElementById('themeToggle');
 const body = document.body;

 // Theme Toggle Logic
 themeToggle.addEventListener('click', () => {
 const currentTheme = body.getAttribute('data-theme');
 if (currentTheme === 'light') {
 body.setAttribute('data-theme', 'dark');
 } else {
 body.setAttribute('data-theme', 'light');
 }
 });

 // Live Chart Data Simulation
 const bars = [document.getElementById('bar1'), document.getElementById('bar2'), document.getElementById('bar3'), document.getElementById('bar4')];
 const metricsContainer = document.getElementById('metricsContainer');

 function generateMetrics() {
 let html = '';
 for (let i = 1; i <= 4; i++) {
 const value = Math.floor(Math.random() * 200) + 50;
 html += `
 <div class="metric">
 Metric ${i}
 ${value}%
 
 `;
 }
 metricsContainer.innerHTML = html;
 }

 function updateChart() {
 bars.forEach((bar, index) => {
 const value = Math.floor(Math.random() * 200) + 50;
 bar.setAttribute('y', 250 - value);
 bar.setAttribute('height', value);
 });
 }

 generateMetrics();
 updateChart();
 setInterval(updateChart, 2000);

<!DOCTYPE html>
<html lang="de">

 <meta charset="UTF-8">
 ChromaLands Explorer
 
 body { margin: 0; overflow: hidden; background: #1a1a2e; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; }
 canvas { display: block; cursor: crosshair; }
 #ui { position: absolute; top: 20px; left: 20px; background: rgba(255,255,255,0.1); backdrop-filter: blur(10px); padding: 20px; border-radius: 15px; color: white; box-shadow: 0 4px 20px rgba(0,0,0,0.3); }
 h1 { margin: 0; font-size: 24px; color: #4cc9f0; }
 p { margin: 5px 0; font-size: 14px; opacity: 0.8; }
 .controls { margin-top: 15px; display: flex; gap: 10px; }
 button { background: #4cc9f0; border: none; padding: 10px 20px; border-radius: 8px; color: white; font-weight: bold; cursor: pointer; transition: transform 0.2s; }
 button:hover { transform: scale(1.05); background: #4895ef; }
 #time { font-size: 20px; margin-bottom: 10px; }
 .info { font-size: 12px; margin-top: 10px; opacity: 0.6; }
 

<canvas id="landscape">

<div id="ui">
 ChromaLands Explorer
 Procedural landscape with dynamic lighting
 <div id="time">Zeit: 12:00
 <div class="controls">
 <button onclick="generateNew()">Neue Landschaft
 <button onclick="takeSnapshot()">PNG speichern
 
 <div class="info">Bewegen Sie die Maus für interaktive Beleuchtung. Klick zum "Einfrieren" der Landschaft.

const canvas = document.getElementById('landscape');
const ctx = canvas.getContext('2d');
let width, height;

// --- Perlin Noise ---
const noise = (x) => {
 let n = Math.sin(x * 12.56) * Math.cos(y * 7.85);
 return (n + 1) / 2; // Normalisiert [0, 1]
};

// --- Landschafts-Parameter ---
let landscape = [];
const numLines = 60; // Höhe der Landschaft in Pixeln

function init() {
 width = canvas.width = window.innerWidth;
 height = canvas.height = window.innerHeight;
 generateNew();
}

function generateNew() {
 landscape = [];
 for (let i = 0; i < numLines; i++) {
 const line = [];
 for (let j = 0; j < width; j++) {
 const noiseVal = Math.random(); // Einfachere Noise für Demo, kann durch Perlin ersetzt werden
 const height = noiseVal * numLines;
 line.push(height);
 }
 landscape.push(line);
 }
 render();
}

function render() {
 ctx.clearRect(0, 0, width, height);
 const currentTime = new Date().getHours() + (new Date().getMinutes() / 60);
 const sunAngle = (currentTime * Math.PI) / 12; // Tag/Nacht-Zyklus

 for (let i = numLines - 1; i >= 0; i--) {
 const lineHeight = landscape[i];
 const y = height - lineHeight;

 // Farbe basierend auf Höhe und Zeit
 let color;
 if (i < numLines * 0.2) { // Berge/Himmel
 color = `rgb(${150 + Math.sin(sunAngle) * 50}, ${200 + Math.cos(sunAngle) * 30}, ${255})`;
 } else if (i < numLines * 0.6) { // Wald/Hügel
 color = `rgb(${50 + Math.sin(sunAngle) * 20}, ${120 + Math.cos(sunAngle) * 40}, ${50})`;
 } else { // Wasser/Tal
 color = `rgb(${20 + Math.sin(sunAngle) * 10}, ${60 + Math.cos(sunAngle) * 20}, ${80})`;
 }

 ctx.fillStyle = color;
 ctx.fillRect(0, y, width, 1);

 // Schatteneffekt
 if (i > numLines * 0.4) {
 ctx.fillStyle = 'rgba(0,0,0,0.2)';
 ctx.fillRect(i * (width / numLines), y + 1, width / numLines, 2);
 }
 }

 document.getElementById('time').innerText = `Zeit: ${Math.floor(currentTime).toString().padStart(2, '0')}:${Math.floor((currentTime % 1) * 60).toString().padStart(2, '0')}`;
}

function takeSnapshot() {
 const link = document.createElement('a');
 link.download = 'chromalands_snapshot.png';
 link.href = canvas.toDataURL();
 link.click();
}

window.addEventListener('resize', init);
canvas.addEventListener('mousedown', () => {
 // Klick freeze landscape (optional)
});

canvas.addEventListener('mousemove', (e) => {
 // Interaktive Beleuchtung bei Mausbewegung
 const mouseX = e.clientX;
 const mouseY = e.clientY;

 // Einfacher Schatteneffekt bei Mausbewegung
 ctx.fillStyle = 'rgba(255,255,255,0.1)';
 ctx.beginPath();
 ctx.arc(mouseX, mouseY, 50, 0, Math.PI * 2);
 ctx.fill();

 requestAnimationFrame(render);
});

init();

using UnityEngine;
using UnityEngine.UIElements;
using System.Collections.Generic;

namespace AileyMenuSystem
{
 public enum GameState { InGame, Paused, Shop, Settings }

 public class DynamicMenuController : MonoBehaviour
 {
 [Header("UI Elements")]
 [SerializeField] private VisualElement root;
 [SerializeField] private Label titleLabel;

 private Button pauseButton;
 private Button shopButton;
 private Button settingsButton;

 private void OnEnable()
 {
 // Initialisiere die UI
 InitializeMenu();
 }

 private void InitializeMenu()
 {
 if (root == null)
 {
 root = GetComponent();
 }

 // USS Styling direkt im Code (für den "Ailey-Touch")
 root.style.backgroundColor = new Color(0.1f, 0.1f, 0.2f);
 root.style.padding = new Length(30, 30);
 root.style.flexDirection = FlexDirection.Column;
 root.style.alignItems = Align.Center;

 titleLabel = root.Q();
 if (titleLabel != null)
 {
 titleLabel.text = "Dynamic Context Menu";
 titleLabel.style.fontSize = 24;
 titleLabel.style.color = Color.white;
 }

 // Erzeuge Buttons dynamisch basierend auf GameState
 CreateMenuButtons(GameState.Paused);
 }

 private void CreateMenuButtons(GameState currentState)
 {
 root.Clear(); // Alte Buttons entfernen

 // Titel neu erstellen
 Label title = new Label($"Menu: {currentState}");
 title.style.fontSize = 24;
 title.style.color = Color.white;
 root.Add(title);

 // Buttons basierend auf Status generieren
 switch (currentState)
 {
 case GameState.Paused:
 CreateButton("Resume", () => Debug.Log("Resuming..."), Color.green);
 CreateButton("Shop", () => ChangeState(GameState.Shop), Color.blue);
 CreateButton("Settings", () => ChangeState(GameState.Settings), Color.gray);
 break;

 case GameState.Shop:
 CreateButton("Back to Pause", () => ChangeState(GameState.Paused), Color.green);
 CreateButton("Buy Item 1", () => Debug.Log("Bought item 1"), Color.blue);
 CreateButton("Buy Item 2", () => Debug.Log("Bought item 2"), Color.blue);
 break;

 case GameState.Settings:
 CreateButton("Back to Pause", () => ChangeState(GameState.Paused), Color.green);
 CreateButton("Volume Up", () => Debug.Log("Volume up"), Color.gray);
 CreateButton("Graphics Quality", () => Debug.Log("Graphics quality changed"), Color.gray);
 break;

 case GameState.InGame:
 CreateButton("Pause", () => ChangeState(GameState.Paused), Color.red);
 break;
 }
 }

 private void CreateButton(string text, System.Action action, Color buttonColor)
 {
 Button btn = new Button();
 btn.text = text;
 btn.style.backgroundColor = buttonColor;
 btn.style.paddingLeft = 20;
 btn.style.paddingRight = 20;
 btn.style.marginRight = 10;
 btn.style.marginBottom = 10;
 btn.style.color = Color.white;

 btn.clicked += () => action?.Invoke();
 root.Add(btn);
 }

 private void ChangeState(GameState newState)
 {
 Debug.Log($"Changing state to: {newState}");
 CreateMenuButtons(newState);
 }

 private void OnDisable()
 {
 root?.Clear();
 }
 }
}

<!DOCTYPE html>
<html lang="de">

 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 Aileys Lab Portfolio
 
 :root {
 --primary-color: #6c5ce7;
 --secondary-color: #a29bfe;
 --accent-color: #ff7675;
 --bg-color: #f8f9fa;
 --text-color: #2d3436;
 --card-bg: #ffffff;
 }

 * {
 margin: 0;
 padding: 0;
 box-sizing: border-box;
 }

 body {
 font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
 background-color: var(--bg-color);
 color: var(--text-color);
 overflow-x: hidden;
 }

 header {
 padding: 2rem;
 text-align: center;
 background: linear-gradient(135deg, var(--primary-color), var(--secondary-color));
 color: white;
 }

 .container {
 max-width: 1200px;
 margin: 2rem auto;
 padding: 0 1rem;
 }

 .portfolio-grid {
 display: grid;
 grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
 gap: 2rem;
 }

 .portfolio-item {
 background: var(--card-bg);
 border-radius: 15px;
 padding: 2rem;
 box-shadow: 0 10px 30px rgba(0, 0, 0, 0.1);
 transition: transform 0.3s ease, box-shadow 0.3s ease;
 position: relative;
 overflow: hidden;
 }

 .portfolio-item:hover {
 transform: translateY(-10px);
 box-shadow: 0 20px 40px rgba(108, 92, 231, 0.2);
 }

 .portfolio-item h3 {
 margin-bottom: 1rem;
 color: var(--primary-color);
 }

 .portfolio-item p {
 font-size: 0.9rem;
 line-height: 1.6;
 }

 .portfolio-item .tags {
 margin-top: 1rem;
 display: flex;
 flex-wrap: wrap;
 gap: 0.5rem;
 }

 .tag {
 padding: 0.25rem 0.75rem;
 background: #eee;
 border-radius: 20px;
 font-size: 0.8rem;
 }

 .portfolio-item .overlay {
 position: absolute;
 top: 0;
 left: 0;
 width: 100%;
 height: 100%;
 background: rgba(108, 92, 231, 0.9);
 color: white;
 display: flex;
 flex-direction: column;
 justify-content: center;
 align-items: center;
 opacity: 0;
 transition: opacity 0.3s ease;
 }

 .portfolio-item:hover .overlay {
 opacity: 1;
 }

 .overlay h4 {
 font-size: 1.5rem;
 margin-bottom: 0.5rem;
 }

 .overlay p {
 font-size: 0.9rem;
 text-align: center;
 }

 footer {
 padding: 2rem;
 text-align: center;
 font-size: 0.8rem;
 }

 @media (max-width: 768px) {
 .portfolio-grid {
 grid-template-columns: 1fr;
 }
 }
 

 Aileys Lab
 Digital Art & Interactive Experiences

<div class="container">
 <div class="portfolio-grid">
 <!-- Item 1 -->
 <div class="portfolio-item">
 Neon Shadows
 Interactive installation exploring the contrast between light and dark in urban environments.
 <div class="tags">
 <span class="tag">Interactive
 <span class="tag">Installation
 <span class="tag">Neon
 
 <div class="overlay">
 More Info
 Learn about the technology behind Neon Shadows.
 
 

 <!-- Item 2 -->
 <div class="portfolio-item">
 Digital Fluidity
 Generative art piece based on fluid dynamics and particle systems.
 <div class="tags">
 <span class="tag">Generative
 <span class="tag">Fluid
 <span class="tag">Interactive
 
 <div class="overlay">
 More Info
 Explore the physics of Digital Fluidity.
 
 

 <!-- Item 3 -->
 <div class="portfolio-item">
 Organic Structures
 3D models inspired by biological growth patterns.
 <div class="tags">
 <span class="tag">3D
 <span class="tag">Organic
 <span class="tag">Generative
 
 <div class="overlay">
 More Info
 Discover the evolution of Organic Structures.
 
 

 <!-- Item 4 -->
 <div class="portfolio-item">
 Soundscapes
 Interactive audio installation based on real-time user interaction.
 <div class="tags">
 <span class="tag">Interactive
 <span class="tag">Audio
 <span class="tag">Generative
 
 <div class="overlay">
 More Info
 Experience the sound of interaction.
 
 

 <!-- Item 5 -->
 <div class="portfolio-item">
 Virtual Gardens
 Interactive VR garden based on real plant growth.
 <div class="tags">
 <span class="tag">VR
 <span class="tag">Interactive
 <span class="tag">Organic
 
 <div class="overlay">
 More Info
 Step into the virtual garden.
 
 

 <!-- Item 6 -->
 <div class="portfolio-item">
 Kinetic Shadows
 Interactive installation based on movement and light.
 <div class="tags">
 <span class="tag">Interactive
 <span class="tag">Kinetic
 <span class="tag">Shadows
 
 <div class="overlay">
 More Info
 Learn about the movement of Kinetic Shadows.
 
 
 

 &copy; 2023 Aileys Lab. All rights reserved.

 // Kleine Interaktion: Beim Klick auf ein Item wird es leicht vergrößert und bleibt so.
 const items = document.querySelectorAll('.portfolio-item');

 items.forEach(item => {
 item.addEventListener('click', () => {
 item.style.transform = 'scale(1.05)';
 item.style.transition = 'transform 0.3s ease';
 });
 });

 // Dynamische Titel-Änderung beim Scrollen (kleiner Effekt)
 window.addEventListener('scroll', () => {
 const header = document.querySelector('header h1');
 if (window.scrollY > 50) {
 header.style.opacity = '0.8';
 } else {
 header.style.opacity = '1';
 }
 });

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace OrganicTweenEngine
{
 /// 
 /// Core Tween class with organic motion.
 /// 
 [RequireComponent(typeof(Rigidbody))]
 public class OrganicTween : MonoBehaviour
 {
 [Header("Target Properties")]
 [SerializeField] private Vector3 targetPosition;
 [SerializeField] private Quaternion targetRotation;

 [Header("Organic Settings")]
 [Range(0.1f, 5.0f)] [SerializeField] private float duration = 2.0f;
 [Range(0.1f, 5.0f)] [SerializeField] private float elasticFactor = 1.2f;
 [Range(0.1f, 5.0f)] [SerializeField] private float resonanceAmount = 0.3f;
 [Range(0.1f, 5.0f)] [SerializeField] private float resonanceSpeed = 2.0f;

 private Vector3 _startPosition;
 private Quaternion _startRotation;
 private float _elapsedTime = 0f;
 private bool _isActive = false;

 private void Start()
 {
 _startPosition = transform.position;
 _startRotation = transform.rotation;
 }

 public void Play()
 {
 _isActive = true;
 _elapsedTime = 0f;
 }

 private void Update()
 {
 if (!_isActive) return;

 _elapsedTime += Time.deltaTime;
 float progress = Mathf.Clamp01(_elapsedTime / duration);

 // Standard Ease Out
 float easeOut = 1.0f - Mathf.Pow(1.0f - progress, 2);

 // Organic Resonance (kleines Zittern)
 float resonance = Mathf.Sin(Time.time * resonanceSpeed) * resonanceAmount;

 // Calculate final values
 Vector3 currentPos = Vector3.Lerp(_startPosition, targetPosition, easeOut + resonance * 0.1f);
 Quaternion currentRot = Quaternion.Slerp(_startRotation, targetRotation, easeOut + resonance * 0.1f);

 transform.position = currentPos;
 transform.rotation = currentRot;

 if (progress >= 1.0f)
 {
 _isActive = false;
 Debug.Log("Organic Tween Complete!");
 }
 }

 // Helpers for random target generation
 [ContextMenu("Set Random Target")]
 private void SetRandomTarget()
 {
 targetPosition = new Vector3(Random.Range(-5f, 5f), Random.Range(-5f, 5f), Random.Range(-5f, 5f));
 targetRotation = Quaternion.Euler(Random.Range(0f, 360f), Random.Range(0f, 360f), Random.Range(0f, 360f));
 Debug.Log($"New target set: {targetPosition}");
 }
 }

 /// 
 /// Global manager to handle multiple tweens.
 /// 
 public class TweenManager : MonoBehaviour
 {
 [SerializeField] private List activeTweens = new List();

 private void Start()
 {
 foreach (var tween in activeTweens)
 {
 tween.Play();
 }
 }

 [ContextMenu("Restart All")]
 private void RestartAll()
 {
 foreach (var tween in activeTweens)
 {
 tween.Play();
 }
 }
 }
}

use std::fs;
use std::path::{Path, PathBuf};
use std::io::{self, Write};
use rand::Rng;

// Nerd Font icons für den Tree-Look
const ICON_DIR: &str = "📁";
const ICON_FILE: &str = "📄";
const ICON_LINK: &str = "🔗";

#[derive(Debug)]
enum EntryType {
 Directory,
 File,
 Link,
}

struct TreeEntry {
 path: PathBuf,
 entry_type: EntryType,
 children: Vec,
}

impl TreeEntry {
 fn new(path: PathBuf) -> Self {
 let metadata = fs::metadata(&path).ok();
 let entry_type = if let Some(m) = metadata {
 if m.is_dir() { EntryType::Directory }
 else if m.file_type().is_symlink() { EntryType::Link }
 else 
 else { EntryType::File }
 } else { EntryType::File };

 TreeEntry { path, entry_type, children: Vec::new() }
 }

 fn build(&mut self) {
 if let EntryType::Directory = self.entry_type {
 if let Ok(entries) = fs::read_dir(&self.path) {
 for entry in entries.flatten() {
 let child = TreeEntry::new(entry.path());
 child.build();
 self.children.push(child);
 }
 }
 }
 }

 fn render(&self, indent: usize) {
 let prefix = " ".repeat(indent);
 let icon = match self.entry_type {
 EntryType::Directory => ICON_DIR,
 EntryType::File => ICON_FILE,
 EntryType::Link => ICON_LINK,
 };

 println!("{}{}{}", prefix, icon, self.path.file_name().unwrap_or(Path::new("unknown")));

 for child in &self.children {
 child.render(indent + 1);
 }
 }

 fn render_neomorphed(&self, indent: usize) {
 let prefix = " ".repeat(indent);
 let icon = match self.entry_type {
 EntryType::Directory => ICON_DIR,
 EntryType::File => ICON_FILE,
 EntryType::Link => ICON_LINK,
 };

 let color = match self.entry_type {
 EntryType::Directory => "cyan",
 EntryType::File => "green",
 EntryType::Link => "magenta",
 };

 println!(
 "{} {}{} {:<30} [Type: {}]",
 prefix, icon, self.path.file_name().unwrap_or(Path::new("unknown")), color, "neomorph"
 );

 for child in &self.children {
 child.render_neomorphed(indent + 1);
 }
 }
}

fn main() {
 println!("--- TreeMorpher v1.0 ---");
 println!("Enter directory path (e.g., '.'): ");

 let mut input = String::new();
 io::stdin().read_line(&mut input).expect("Failed to read line");

 let path = PathBuf::from(input.trim());
 if !path.exists() {
 println!("Path does not exist!");
 return;
 }

 let mut root = TreeEntry::new(path);
 root.build();

 println!("\n--- Standard Tree ---");
 root.render(0);

 println!("\n--- Neomorphed Tree ---");
 root.render_neomorphed(0);

 println!("\n--- Random Color Tree ---");
 let mut rng = rand::thread_rng();

 fn render_random(&self, indent: usize) {
 let prefix = " ".repeat(indent);
 let icon = match self.entry_type {
 EntryType::Directory => ICON_DIR,
 EntryType::File => ICON_FILE,
 EntryType::Link => ICON_LINK,
 };

 let colors = ["red", "blue", "yellow", "white", "gray"];
 let color = colors[rng.gen_range(0..colors.len())];

 println!(
 "{} {}{} {:<30} [Type: {}]",
 prefix, icon, self.path.file_name().unwrap_or(Path::new("unknown")), color, "neomorph"
 );

 for child in &self.children {
 child.render_random(indent + 1);
 }
 }

 // Add a method to TreeEntry for random rendering - but let's just reuse the logic
 // Since I can't easily add methods to existing structs in this format, let's just use a closure or similar.

 println!("--- Random Color Tree ---");
 // Alternative: Add a method to TreeEntry for random rendering - but let's just reuse the logic
 // Since I can't easily add methods to existing structs in this format, let's just use a closure or similar.

 // Let's just reuse the render_neomorphed but with a random color instead of "cyan", etc.
 // This would require modifying the render_neomorphed method or adding a new one.

 // For now, let's just stick to the two versions and maybe add a third one later.

 println!("\n--- Done ---");
}

import SwiftUI
import CoreData
import Konfetti

// MARK: - CoreData Stack

class PersistenceController {
 static let shared = PersistenceController()

 let container: NSPersistentContainer

 init() {
 container = NSPersistentContainer(name: "MoodNotes")
 container.loadPersistentStores { (description, error) in
 if let error = error as NSError? {
 fatalError("Unresolved error \(error), \(error.userInfo)")
 }
 }
 }

 func save() {
 let context = container.viewContext
 if context.hasChanges {
 do {
 try context.save()
 } catch {
 let nserror = error as NSError
 print("Unresolved error \(nserror), \(nserror.userInfo)")
 }
 }
 }
}

// MARK: - Data Model

// Note-Entität mit Title, Content und Mood-Enum
// Mood-Enum-Werte: happy, neutral, sad, creative

// MARK: - Views

struct MoodNotesView: View {
 @Environment(\.managedObjectContext) private var viewContext

 @FetchRequest(
 fetchRequest: NSFetchRequest(entityName: "Note"),
 sortDescriptors: [NSSortDescriptor(keyPath: \.timestamp, ascending: false)]
 ) private var notes

 @State private var showingAddNote = false

 var body: some View {
 NavigationView {
 List {
 ForEach(notes) { note in
 NoteRow(note: note)
 }
 .onDelete(perform: deleteNotes)
 }
 .navigationTitle("MoodNotes")
 .toolbar {
 ToolbarItem(placement: .navigationBarTrailing) {
 Button(action: { showingAddNote.toggle() }) {
 Image(systemName: "plus")
 }
 }
 }
 .sheet(isPresented: $showingAddNote) {
 AddNoteView()
 }
 }
 }

 private func deleteNotes(offsets: IndexSet) {
 offsets.map { notes[$0] }.forEach(viewContext.delete)
 PersistenceController.shared.save()
 }
}

struct NoteRow: View {
 let note: Note

 var body: some View {
 VStack(alignment: .leading, spacing: 4) {
 Text(note.title ?? "Titel")
 .font(.headline)
 Text(note.content ?? "")
 .font(.subheadline)
 .lineLimit(2)
 HStack {
 Circle()
 .fill(moodColor(note.mood))
 .frame(width: 12, height: 12)
 Text(note.mood?.rawValue ?? "neutral")
 .font(.caption2)
 .foregroundColor(.gray)
 }
 }
 .padding(.vertical, 4)
 }

 private func moodColor(_ mood: Mood?) -> Color {
 switch mood {
 case .happy: return .yellow
 case .neutral: return .gray
 case .sad: return .blue
 case .creative: return .purple
 case .none: return .clear
 }
 }
}

struct AddNoteView: View {
 @Environment(\.managedObjectContext) private var viewContext
 @Environment(\.dismiss) private var dismiss

 @State private var title = ""
 @State private var content = ""
 @State private var mood = Mood.neutral

 var body: some View {
 NavigationView {
 Form {
 Section(header: Text("Titel")) {
 TextField("Titel", text: $title)
 }
 Section(header: Text("Inhalt")) {
 TextEditor(text: $content)
 .frame(height: 200)
 }
 Section(header: Text("Mood")) {
 Picker("Mood", selection: $mood) {
 ForEach(Mood.allCases, id: \.self) {
 Text($0.rawValue.capitalized).tag($0)
 }
 }
 }
 }
 .navigationTitle("Neue Notiz")
 .toolbar {
 ToolbarItem(placement: .cancellationAction) {
 Button("Abbrechen") { dismiss() }
 }
 ToolbarItem(placement: .confirmationAction) {
 Button("Speichern") {
 saveNote()
 }
 }
 }
 }
 }

 private func saveNote() {
 let newNote = Note(context: viewContext)
 newNote.title = title
 newNote.content = content
 newNote.mood = mood
 newNote.timestamp = Date()

 PersistenceController.shared.save()
 dismiss()

 // Konfetti-Animation
 let config = KonfettiConfig(
 colors: [.yellow, .blue, .purple, .gray],
 numberOfPieces: 20,
 gravity: 0.5,
 horizontalSpeed: 2.0
 )
 Konfetti.burst(config: config)
 }
}

// MARK: - Helpers

enum Mood: String, CaseIterable {
 case happy
 case neutral
 case sad
 case creative
}

// MARK: - Preview

struct MoodNotes_Previews: PreviewProvider {
 static var previews: some View {
 MoodNotesView()
 .environment(\.managedObjectContext, PersistenceController.shared.container.viewContext)
 }
}

// MARK: - CoreData Entities

// Note-Entität
// title: String
// content: String
// mood: Mood (Enum-Wert als String gespeichert)
// timestamp: Date

// Konfetti-Animation-Implementierung (Pseudo-Code da Konfetti-Lib-Details variieren können)
// Für dieses Beispiel wird eine einfache Konfetti-Animation-Funktion simuliert.

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// MARK: - Konfetti-Animation-Pseudo-Code

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animation-Pseudo-Code
// Konfetti.burst(config: config)

// Konfetti-Animati

```html
<!DOCTYPE html>
<html lang="de">

 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 NebulaLens - Creative Gallery
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
 <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600&display=swap" rel="stylesheet">
 
 :root {
 --bg: #0a0a0c;
 --surface: #16161e;
 --accent: #6366f1;
 --text: #e2e8f0;
 --text-muted: #94a3b8;
 --transition: 0.4s cubic-bezier(0.23, 1, 0.32, 1);
 }

 * {
 margin: 0;
 padding: 0;
 box-sizing: border-box;
 }

 body {
 background: var(--bg);
 color: var(--text);
 font-family: 'Inter', sans-serif;
 overflow-x: hidden;
 }

 /* --- Header & Filters --- */
 header {
 padding: 2rem;
 text-align: center;
 background: linear-gradient(to bottom, rgba(22,22,30,1), rgba(10,10,12,0));
 position: sticky;
 top: 0;
 z-index: 100;
 backdrop-filter: blur(10px);
 }

 h1 {
 font-weight: 600;
 letter-spacing: -0.02em;
 margin-bottom: 1rem;
 background: linear-gradient(45deg, #818cf8, #c084fc);
 -webkit-background-clip: text;
 -webkit-text-fill-color: transparent;
 }

 .filters {
 display: flex;
 justify-content: center;
 gap: 1rem;
 flex-wrap: wrap;
 }

 .filter-btn {
 background: var(--surface);
 border: 1px solid rgba(255,255,255,0.1);
 color: var(--text);
 padding: 0.6rem 1.2rem;
 border-radius: 20px;
 cursor: pointer;
 transition: var(--transition);
 font-size: 0.9rem;
 }

 .filter-btn:hover, .filter-btn.active {
 background: var(--accent);
 border-color: var(--accent);
 transform: translateY(-2px);
 }

 /* --- Masonry Grid --- */
 .gallery-container {
 padding: 2rem;
 max-width: 1200px;
 margin: 0 auto;
 display: grid;
 grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
 gap: 20px;
 grid-auto-flow: dense;
 }

 .gallery-item {
 position: relative;
 border-radius: 12px;
 overflow: hidden;
 background: var(--surface);
 transition: transform 0.3s ease;
 cursor: pointer;
 animation: fadeIn 0.8s ease forwards;
 }

 .gallery-item:hover {
 transform: scale(1.02);
 box-shadow: 0 10px 30px rgba(0,0,0,0.5);
 }

 .gallery-item img {
 width: 100%;
 height: auto;
 display: block;
 transition: filter 0.3s ease;
 }

 .gallery-item:hover img {
 filter: brightness(1.1) contrast(1.1);
 }

 .gallery-item .overlay {
 position: absolute;
 bottom: 0;
 left: 0;
 right: 0;
 padding: 1rem;
 background: linear-gradient(transparent, rgba(0,0,0,0.8));
 opacity: 0;
 transition: opacity 0.3s ease;
 }

 .gallery-item:hover .overlay {
 opacity: 1;
 }

 /* --- Lightbox --- */
 #lightbox {
 position: fixed;
 top: 0;
 left: 0;
 width: 100%;
 height: 100%;
 background: rgba(0,0,0,0.95);
 display: none;
 justify-content: center;
 align-items: center;
 z-index: 1000;
 backdrop-filter: blur(8px);
 animation: fadeIn 0.3s ease;
 }

 #lightbox.active {
 display: flex;
 }

 .lightbox-content {
 max-width: 90%;
 max-height: 80vh;
 border-radius: 8px;
 box-shadow: 0 0 50px rgba(0,0,0,0.8);
 transform: scale(0.8);
 transition: transform 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275);
 }

 #lightbox.active .lightbox-content {
 transform: scale(1);
 }

 .close-lightbox {
 position: absolute;
 top: 20px;
 right: 20px;
 font-size: 2rem;
 color: white;
 cursor: pointer;
 user-select: none;
 }

 /* --- Animations --- */
 @keyframes fadeIn {
 from { opacity: 0; transform: translateY(20px); }
 to { opacity: 1; transform: translateY(0); }
 }

 /* --- Mobile --- */
 @media (max-width: 600px) {
 .gallery-container {
 grid-template-columns: 1fr;
 padding: 1rem;
 }
 .filters {
 gap: 0.5rem;
 }
 .filter-btn {
 padding: 0.5rem 0.8rem;
 font-size: 0.8rem;
 }
 }
 

 
 NebulaLens
 <div class="filters">
 <button class="filter-btn active" data-filter="all">All
 <button class="filter-btn" data-filter="nature">Nature
 <button class="filter-btn" data-filter="urban">Urban
 <button class="filter-btn" data-filter="abstract">Abstract
 <button class="filter-btn" data-filter="portrait">Portrait
 
 

 <main class="gallery-container" id="gallery">
 <!-- Bilder werden dynamisch geladen -->
 

 <div id="lightbox">
 <span class="close-lightbox">&times;
 <img class="lightbox-content" src="" alt="">
 

 
 const images = [
 { url: 'https://images.unsplash.com/photo-1464822759023-fed6f285608c', title: 'Mountain Peak', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1449824913935-59a10b0c904c', title: 'Urban Jungle', category: 'urban' },
 { url: 'https://images.unsplash.com/photo-1506744038136-46273834b3fb', title: 'Crystal Waters', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1493246507139-91e8fad99f00', title: 'Golden Hour', category: 'abstract' },
 { url: 'https://images.unsplash.com/photo-1500628550465-85811080888c', title: 'Stormy Clouds', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1480714608261-30410088888c', title: 'Neon Streets', category: 'urban' },
 { url: 'https://images.unsplash.com/photo-1534528741775-53994a69daeb', title: 'Soul Gaze', category: 'portrait' },
 { url: 'https://images.unsplash.com/photo-1501854140801-50d010095288', title: 'Desert Sands', category: 'abstract' },
 { url: 'https://images.unsplash.com/photo-1469474099680-d123e1eb82c6', title: 'Deep Forest', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1470071459604-46d5c18b471e', title: 'River Flow', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1444703686981-a3e884000c0c', title: 'Old Bridge', category: 'urban' },
 { url: 'https://images.unsplash.com/photo-1506744038136-46273834b3fb', title: 'Crystal Waters', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1464822759023-fed6f285608c', title: 'Mountain Peak', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1464822759023-fed6f285608c', title: 'Mountain Peak', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1464822759023-fed6f285608c', title: 'Mountain Peak', category: 'nature' },
 { url: 'https://images.unsplash.com/photo-1464822759023-fed6f285608c',

#!/usr/bin/env node
// =============================================
// ZEUS - Zettabyte Encrypted Uniform Store
// =============================================
// A creative Node.js environment variable manager with AES-256 encryption
// Features:
// - Generate memorable 6-digit hex keys for unlocking encrypted data
// - Interactive CLI for managing encrypted environment variables
// - Store encrypted variables in a secure JSON file (~/.zeus-vault.json)
// - Modern ES modules with conditional compilation for CommonJS
// =============================================

const fs = require('fs').promises;
const path = require('path');
const readline = require('readline');
const crypto = require('crypto');
const os = process.platform;

const VAULT_FILE = path.join(os === 'win32' ? process.env.LOCALAPPDATA : path.expand('~/.zeus-vault'), 'zeus-vault.json');

// Modern ES modules with conditional compilation for CommonJS
let generateKey, encrypt, decrypt, loadVault, saveVault, cli;

if (typeof module !== 'undefined' && module.exports) {
  // CommonJS compilation
  ({ generateKey, encrypt, decrypt, loadVault, saveVault, cli } = require('./zeus-modules.js'));
} else {
  // ES modules compilation
  ({ generateKey, encrypt, decrypt, loadVault, saveVault, cli } = await import('./zeus-modules.js'));
}

// Initialize vault if it doesn't exist
async function initVault() {
  try {
    await loadVault();
  } catch (err) {
    if (err.code !== 'ENOENT') throw err;
    const vault = { encrypted: [], keyHash: null };
    await saveVault(vault);
    console.log('🌱 Created new ZEUS vault');
  }
}

async function main() {
  await initVault();

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  await cli(rl);
  rl.close();
}

// Export for CommonJS usage
if (typeof module !== 'undefined' && module.exports) {
  module.exports = { main, generateKey, encrypt, decrypt, loadVault, saveVault };
}

// Run the application if executed directly
if (require.main === module) {
  main().catch(console.error);
}

<?php
/**
 * Plugin Name: Smart Maintenance Mode with Social Share
 * Description: Displays a stylish countdown during maintenance with social sharing options
 * Version: 1.0
 * Author: Ailey
 * Author URI: https://github.com/ailey
 * License: GPL2
 */

if (!defined('ABSPATH')) exit; // Exit if accessed directly

class SmartMaintenanceMode {

    private $maintenance_time;
    private $time_left;

    public function __construct() {
        $this->maintenance_time = get_option('smart_maintenance_end', time() + 3600); // Default 1 hour
        $this->time_left = max(0, $this->maintenance_time - time());

        if ($this->time_left > 0) {
            add_action('wp_head', [$this, 'add_maintenance_styles']);
            add_action('wp_footer', [$this, 'add_maintenance_scripts']);
            remove_action('wp_head', 'wp_generator'); // Hide WordPress version
        }
    }

    public function add_maintenance_styles() {
        echo '<style>
            #maintenance-mode {
                position: fixed;
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
                background: linear-gradient(135deg, #2c3e50, #34495e);
                color: white;
                display: flex;
                flex-direction: column;
                justify-content: center;
                align-items: center;
                z-index: 9999;
                text-align: center;
                font-family: \'Helvetica Neue\', Arial, sans-serif;
            }
            #maintenance-logo {
                font-size: 3rem;
                margin-bottom: 1rem;
                animation: pulse 2s infinite;
            }
            @keyframes pulse {
                0% { opacity: 1; }
                50% { opacity: 0.7; }
                100% { opacity: 1; }
            }
            #countdown-timer {
                font-size: 2.5rem;
                margin-bottom: 2rem;
                font-weight: bold;
            }
            #maintenance-message {
                font-size: 1.5rem;
                max-width: 800px;
                line-height: 1.6;
                margin-bottom: 2rem;
            }
            .share-buttons {
                display: flex;
                gap: 1rem;
                justify-content: center;
                flex-wrap: wrap;
            }
            .share-btn {
                background: #3498db;
                color: white;
                border: none;
                padding: 0.8rem 1.5rem;
                border-radius: 5px;
                font-size: 1rem;
                cursor: pointer;
                transition: background 0.3s;
            }
            .share-btn:hover {
                background: #2980b9;
            }
            #maintenance-footer {
                position: absolute;
                bottom: 20px;
                font-size: 0.9rem;
                color: #bdc3c7;
            }
        </style>';
    }

    public function add_maintenance_scripts() {
        echo '<div id="maintenance-mode">
            <div id="maintenance-logo">🛠️</div>
            <div id="countdown-timer">
                <span id="days">0</span> Days
                <span id="hours">0</span> Hours
                <span id="minutes">0</span> Minutes
                <span id="seconds">0</span> Seconds
            </div>
            <div id="maintenance-message">
                We\'re making our website better! Please come back soon.
                <br>
                Meanwhile, share this page with your friends - we\'ll appreciate it!
            </div>
            <div class="share-buttons">
                <button class="share-btn" onclick="shareTwitter()">Share on Twitter</button>
                <button class="share-btn" onclick="shareFacebook()">Share on Facebook</button>
                <button class="share-btn" onclick="shareLinkedIn()">Share on LinkedIn</button>
                <button class="share-btn" onclick="shareEmail()">Email to Friend</button>
            </div>
            <div id="maintenance-footer">
                Maintenance mode will end: ' . date('F j, Y H:i', $this->maintenance_time) . '
            </div>
        </div>

        <script>
            function updateCountdown() {
                const totalSeconds = ' . $this->time_left . ';
                const days = Math.floor(totalSeconds / 86400);
                const hours = Math.floor((totalSeconds % 86400) / 3600);
                const minutes = Math.floor((totalSeconds % 3600) / 60);
                const seconds = totalSeconds % 60;

                document.getElementById("days").textContent = days;
                document.getElementById("hours").textContent = hours;
                document.getElementById("minutes").textContent = minutes;
                document.getElementById("seconds").textContent = seconds;
            }

            function shareTwitter() {
                const url = encodeURIComponent(window.location.href);
                const text = encodeURIComponent("Check out this website during maintenance! It'll be back soon - please share if you can!");
                window.open(`https://twitter.com/intent/tweet?url=${url}&text=${text}`, "_blank");
            }

            function shareFacebook() {
                const url = encodeURIComponent(window.location.href);
                const title = encodeURIComponent("Website Maintenance Notice");
                const description = encodeURIComponent("This website is temporarily down for maintenance. Please share if you can!");
                window.open(`https://www.facebook.com/sharer/sharer.php?u=${url}&quote=${title}&caption=${description}`, "_blank");
            }

            function shareLinkedIn() {
                const url = encodeURIComponent(window.location.href);
                const title = encodeURIComponent("Website Maintenance Notice");
                const text = encodeURIComponent("This website is temporarily down for maintenance. Please share if you can!");
                window.open(`https://www.linkedin.com/shareArticle?mini=true&url=${url}&title=${title}&summary=${text}`, "_blank");
            }

            function shareEmail() {
                window.open(`mailto:?subject=Check%20this%20website&body=${window.location.href}%0D%0AThis%20website%20is%20temporarily%20down%20for%20maintenance.%20Please%20share%20if%20you%20can!`, "_blank");
            }

            setInterval(updateCountdown, 1000);
            updateCountdown();
        </script>';
    }

    public function admin_maintenance_page() {
        if (!current_user_can('manage_options')) return;

        echo '<div class="wrap">
            <h1>Smart Maintenance Mode Settings</h1>
            <form method="post" action="options.php">
                <input type="hidden" name="option_page" value="smart_maintenance_mode">
                <?php settings_fields('smart_maintenance_mode_options'); ?>
                <table class="form-table">
                    <tr>
                        <th>Maintenance Mode Duration</th>
                        <td>
                            <input type="text" name="maintenance_duration" value="' . esc_attr(get_option('maintenance_duration', '3600')) . '" placeholder="Seconds (default: 3600)" />
                            <p class="description">Enter the duration in seconds for maintenance mode (0 for unlimited)</p>
                        </td>
                    </tr>
                </table>
                <p class="submit">
                    <input type="submit" class="button-primary" value="Save Settings" />
                </p>
            </form>
        </div>';
    }

    public function register_settings() {
        register_setting('smart_maintenance_mode_options', 'maintenance_duration', ['type' => 'string', 'sanitize_callback' => 'sanitize_text_field']);
    }
}

$smart_maintenance = new SmartMaintenanceMode();

// For WordPress admin menu
add_action('admin_menu', function() {
    add_submenu_page(
        'tools.php',
        'Maintenance Mode',
        'Maintenance Mode',
        'manage_options',
        'maintenance-mode',
        [$smart_maintenance, 'admin_maintenance_page']
    );
});

// For Joomla compatibility (if needed)
if (!defined('JPATH_BASE')) {
    // This check helps identify if the plugin is loaded in Joomla
    // In a real Joomla plugin, this would be a different structure
    $this->add_maintenance_styles();
    $this->add_maintenance_scripts();
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Markdown Live Preview</title>
    <style>
        :root {
            --primary-color: #4a6fa5;
            --secondary-color: #166088;
            --accent-color: #4fc3f7;
            --bg-color: #f5f7fa;
            --editor-bg: #ffffff;
            --preview-bg: #f9f9f9;
            --text-color: #333333;
            --border-color: #e0e0e0;
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        body {
            background-color: var(--bg-color);
            color: var(--text-color);
            line-height: 1.6;
            padding: 20px;
            min-height: 100vh;
        }

        .container {
            max-width: 1200px;
            margin: 0 auto;
            display: flex;
            flex-direction: column;
            align-items: center;
            gap: 20px;
        }

        header {
            width: 100%;
            padding: 15px 0;
            border-bottom: 1px solid var(--border-color);
            margin-bottom: 20px;
        }

        h1 {
            color: var(--secondary-color);
            font-weight: 600;
            font-size: 2.2rem;
        }

        .editor-container, .preview-container {
            width: 100%;
            display: flex;
            flex-direction: column;
            border-radius: 8px;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
            overflow: hidden;
        }

        .split-pane {
            display: flex;
            flex-direction: row;
            height: 60vh;
            min-height: 500px;
            width: 100%;
            gap: 5px;
        }

        .editor-pane, .preview-pane {
            flex: 1;
            display: flex;
            flex-direction: column;
            position: relative;
            background-color: var(--editor-bg);
        }

        .preview-pane {
            background-color: var(--preview-bg);
        }

        textarea {
            flex: 1;
            padding: 15px;
            border: none;
            background-color: transparent;
            font-size: 14px;
            resize: none;
            outline: none;
            line-height: 1.5;
            font-family: 'Courier New', Courier, monospace;
        }

        .preview-content {
            flex: 1;
            padding: 15px;
            overflow-y: auto;
            background-color: var(--preview-bg);
        }

        .toolbar {
            padding: 10px 15px;
            background-color: var(--editor-bg);
            border-bottom: 1px solid var(--border-color);
            display: flex;
            gap: 10px;
            flex-wrap: wrap;
        }

        .toolbar button {
            padding: 8px 12px;
            border: none;
            background-color: var(--primary-color);
            color: white;
            border-radius: 4px;
            cursor: pointer;
            font-size: 12px;
            font-weight: 500;
            transition: background-color 0.2s;
        }

        .toolbar button:hover {
            background-color: var(--secondary-color);
        }

        .toolbar button.active {
            background-color: var(--accent-color);
        }

        .previews-tabs {
            display: flex;
            background-color: var(--preview-bg);
            border-bottom: 1px solid var(--border-color);
        }

        .previews-tabs button {
            padding: 10px 15px;
            border: none;
            background: none;
            color: var(--text-color);
            cursor: pointer;
            font-size: 12px;
            font-weight: 500;
            border-bottom: 3px solid transparent;
            transition: all 0.2s;
        }

        .previews-tabs button:hover {
            color: var(--primary-color);
        }

        .previews-tabs button.active {
            color: var(--accent-color);
            border-bottom-color: var(--accent-color);
        }

        .title {
            font-size: 18px;
            font-weight: 600;
            margin-bottom: 10px;
            color: var(--secondary-color);
        }

        .preview-pane .title {
            color: var(--primary-color);
        }

        .preview Content h1, .preview Content h2, .preview Content h3 {
            margin: 15px 0 10px 0;
            line-height: 1.2;
        }

        .preview Content h1 {
            font-size: 2rem;
            color: var(--secondary-color);
            border-bottom: 2px solid var(--border-color);
            padding-bottom: 5px;
        }

        .preview Content h2 {
            font-size: 1.5rem;
            color: var(--primary-color);
        }

        .preview Content h3 {
            font-size: 1.25rem;
            color: #555;
        }

        .preview Content p {
            margin-bottom: 10px;
        }

        .preview Content ul, .preview Content ol {
            margin: 10px 0 10px 20px;
        }

        .preview Content li {
            margin-bottom: 5px;
        }

        .preview Content blockquote {
            border-left: 3px solid var(--accent-color);
            padding-left: 15px;
            margin: 10px 0;
            color: #555;
            font-style: italic;
        }

        .preview Content img {
            max-width: 100%;
            height: auto;
            margin: 10px 0;
            border-radius: 4px;
        }

        .preview Content table {
            width: 100%;
            border-collapse: collapse;
            margin: 10px 0;
        }

        .preview Content th, .preview Content td {
            border: 1px solid var(--border-color);
            padding: 8px;
            text-align: left;
        }

        .preview Content th {
            background-color: var(--editor-bg);
        }

        .preview Content code {
            background-color: #f0f0f0;
            padding: 2px 4px;
            border-radius: 3px;
            font-family: 'Courier New', Courier, monospace;
        }

        .preview Content pre {
            background-color: #f5f5f5;
            padding: 15px;
            border-radius: 4px;
            overflow-x: auto;
            margin: 10px 0;
        }

        .preview Content pre code {
            background-color: transparent;
            padding: 0;
        }

        .markdown-shortcuts {
            margin-top: 20px;
            font-size: 12px;
            color: #666;
            max-width: 800px;
        }

        .markdown-shortcuts h3 {
            color: var(--secondary-color);
            margin-bottom: 5px;
        }

        .markdown-shortcuts ul {
            list-style-type: none;
            padding-left: 0;
        }

        .markdown-shortcuts li {
            margin-bottom: 3px;
        }

        .markdown-shortcuts a {
            color: var(--primary-color);
            text-decoration: none;
        }

        .markdown-shortcuts a:hover {
            text-decoration: underline;
        }

        .brightness-slider-container {
            margin-top: 15px;
        }

        .brightness-slider-container label {
            display: block;
            margin-bottom: 5px;
            font-size: 12px;
        }

        .brightness-slider-container input {
            width: 100%;
            height: 5px;
            -webkit-appearance: none;
            background: #ddd;
            border-radius: 5px;
            outline: none;
        }

        .brightness-slider-container input::-webkit-slider-thumb {
            -webkit-appearance: none;
            width: 15px;
            height: 15px;
            background: var(--primary-color);
            border-radius: 50%;
            cursor: pointer;
        }

        .brightness-slider-container input::-moz-range-thumb {
            width: 15px;
            height: 15px;
            background: var(--primary-color);
            border-radius: 50%;
            cursor: pointer;
            border: none;
        }

        @media (max-width: 768px) {
            .split-pane {
                flex-direction: column;
                height: auto;
            }

            .preview-content {
                height: 30vh;
            }

            .title {
                font-size: 16px;
            }
        }
    </style>
</head>
<body>
    <div class="container">
        <header>
            <h1>Markdown Live Preview</h1>
        </header>

        <div class="editor-container">
            <div class="toolbar">
                <button class="active" data-format="markdown">Markdown</button>
                <button data-format="html">HTML</button>
                <button data-format="plain">Plain Text</button>
                <button data-format="pdf">PDF Export</button>
                <button data-format="word">Word Export</button>
                <button data-format="copy">Copy to Clipboard</button>
            </div>
            <div class="split-pane">
                <div class="editor-pane">
                    <textarea id="markdown-editor" placeholder="Write your Markdown here..."># Hello World!

This is a **Markdown** live preview editor.

## Features

- Split-pane design with live preview
- Multiple output formats
- Syntax highlighting
- Responsive layout
- Export to PDF and Word
- Copy to clipboard

## How to use

Type Markdown in the left pane and see the rendered output in the right pane.

### Code example

use std::{
    collections::HashMap,
    env,
    fs::File,
    io::{self, Read, Write},
    path::Path,
    process,
    thread,
    time::Duration,
};
use csv::ReaderBuilder;
use itertools::Itertools;
use ratatui::{
    backend::CrosstermBackend,
    layout::{Constraint, Direction, Layout, Rectangle},
    style::{Color, Modifier, Style},
    text::{Span, Spans},
    widgets::{Block, Borders, Paragraph, Tabs},
    Terminal,
};
use crossterm::{
    execute,
    event::{Event, KeyCode},
    terminal::{
        disable_raw_mode, enable_raw_mode, EnterAltScreen, LeaveAltScreen,
    },
};
use serde::Deserialize;
use sqlparser::{
    parser::Parser,
    dialect::GenericDialect,
    ast::{Statement, Expression, BinaryOpExpression, Ident, Table, TableWithJoins, Value},
};

// Glassmorphism UI Constants
const GLASS_BG: Color = Color::Rgb(30, 30, 40);
const GLASS_BORDER: Color = Color::Rgb(50, 50, 60);
const GLASS_TEXT: Color = Color::Rgb(220, 220, 230);
const NEON_HIGHLIGHT: Color = Color::Rgb(100, 200, 255);

// SQL Dialect Customization
const DIALECT: &str = "GenericDialect";

#[derive(Debug, Default)]
struct QueryResult {
    columns: Vec<String>,
    data: Vec<Vec<String>>,
}

#[derive(Debug, Default)]
struct AppState {
    csv_file: Option<String>,
    csv_data: Vec<HashMap<String, String>>,
    query: String,
    results: QueryResult,
    query_history: Vec<String>,
    history_index: usize,
    is_running: bool,
}

impl AppState {
    fn new() -> Self {
        AppState {
            csv_file: None,
            csv_data: Vec::new(),
            query: String::new(),
            results: QueryResult::default(),
            query_history: Vec::new(),
            history_index: 0,
            is_running: true,
        }
    }

    fn load_csv(&mut self, path: &str) -> io::Result<()> {
        let file = File::open(path)?;
        let mut reader = ReaderBuilder::new()
            .has_headers(true)
            .from_reader(file);

        self.csv_data.clear();
        self.results = QueryResult::default();

        for result in reader.records(|r| r.field_ref().map(|_| ())) {
            match result {
                Ok(record) => {
                    let mut row = HashMap::new();
                    for (i, field) in record.iter().enumerate() {
                        if let Some(header) = reader.headers().ok().and_then(|h| h.get(i)) {
                            row.insert(header.to_string(), field.to_string());
                        }
                    }
                    self.csv_data.push(row);
                }
                Err(e) => eprintln!("CSV Read Error: {}", e),
            }
        }
        Ok(())
    }

    fn execute_query(&mut self) {
        if self.csv_data.is_empty() || self.query.trim().is_empty() {
            self.results = QueryResult::default();
            return;
        }

        // Parse SQL
        let parsed = Parser::parse_sql(&self.query).unwrap_or_default();
        if parsed.is_empty() {
            self.results = QueryResult::default();
            return;
        }

        let statement = parsed[0].clone();

        // Validate SELECT statement
        if let Statement::Query(query) = statement {
            if let Some(select) = query.body {
                if let Statement::Select(select) = select {
                    let columns = if let Some( Expression::Select select_expr) = select.expr {
                        // Complex projection handling
                        let col_names = select_expr.projection.iter()
                            .filter_map(|expr| match expr {
                                Expression::Ident(ident) => Some(ident.name.clone()),
                                _ => None,
                            })
                            .collect::<Vec<_>>();
                        if col_names.is_empty() {
                            self.csv_data[0].keys().cloned().collect()
                        } else {
                            col_names
                        }
                    } else {
                        self.csv_data[0].keys().cloned().collect()
                    };

                    let mut filtered_data = Vec::new();

                    // Handle WHERE clause
                    if let Some( Expression::BinaryOpExpression(where_expr)) = select.expr.as_ref().and_then(|e| e.expr.as_ref()) {
                        if let BinaryOpExpression { left, op, right } = where_expr {
                            let column = if let Expression::Ident(ident) = left {
                                ident.name.clone()
                            } else {
                                return;
                            };

                            for row in &self.csv_data {
                                if let Some(value) = row.get(&column) {
                                    let condition_met = match op {
                                        // Equality
                                        BinaryOpExpression::Eq => value == right.to_string(),
                                        // Inequality
                                        BinaryOpExpression::Neq => value != right.to_string(),
                                        // Greater than
                                        BinaryOpExpression::Gt => value.parse::<f64>().unwrap_or(0.0) > right.to_string().parse::<f64>().unwrap_or(0.0),
                                        // Less than
                                        BinaryOpExpression::Lt => value.parse::<f64>().unwrap_or(0.0) < right.to_string().parse::<f64>().unwrap_or(0.0),
                                        // Like pattern matching
                                        BinaryOpExpression::Like => value.contains(&right.to_string()),
                                        _ => false,
                                    };

                                    if condition_met {
                                        let mut filtered_row = Vec::new();
                                        for col in &columns {
                                            filtered_row.push(row.get(col).cloned().unwrap_or_default());
                                        }
                                        filtered_data.push(filtered_row);
                                    }
                                }
                            }
                        }
                    } else {
                        // No WHERE clause - select all matching columns
                        for row in &self.csv_data {
                            let mut filtered_row = Vec::new();
                            for col in &columns {
                                filtered_row.push(row.get(col).cloned().unwrap_or_default());
                            }
                            filtered_data.push(filtered_row);
                        }
                    }

                    // Handle ORDER BY (simplified)
                    if let Some( Expression::OrderBy(order_by)) = select.expr.as_ref() {
                        if let Some( Expression::Ident(ident)) = order_by {
                            if let Ok(index) = columns.iter().position(|c| c == ident.name) {
                                filtered_data.sort_by(|a, b| {
                                    a[index].cmp(b[index])
                                });
                            }
                        }
                    }

                    // Update results
                    self.results.columns = columns;
                    self.results.data = filtered_data;
                }
            }
        }

        // Save to history
        if !self.query.trim().is_empty() {
            self.query_history.push(self.query.clone());
            self.history_index = self.query_history.len();
        }
    }

    fn previous_query(&mut self) {
        if !self.query_history.is_empty() && self.history_index > 0 {
            self.history_index -= 1;
            self.query = self.query_history[self.history_index].clone();
        }
    }

    fn next_query(&mut self) {
        if !self.query_history.is_empty() && self.history_index < self.query_history.len() - 1 {
            self.history_index += 1;
            self.query = self.query_history[self.history_index].clone();
        }
    }
}

fn main() {
    // Initialize terminal
    let mut terminal = Terminal::new(CrosstermBackend::new(io::stdout())).unwrap();
    terminal.hide_cursor().unwrap();

    // Enable raw mode and alt screen
    enable_raw_mode().unwrap();
    execute!(io::stdout(), EnterAltScreen).unwrap();

    // Load Glassmorphism assets
    let glass_assets = vec![
        Span::styled("Loading...", Style::default().fg(GLASS_TEXT)),
        Span::styled("NeonQuery", Style::default().add_modifier(Modifier::BOLD).fg(NEON_HIGHLIGHT)),
    ];

    // Main application loop
    let mut app = AppState::new();

    loop {
        terminal.draw(|f| {
            let size = f.size();

            // Glassmorphism layout
            let glass_layout = Layout::new(
                Direction::Vertical,
                Constraint::Percentage(90),
            )
            .bordered()
            .style(Style::default().bg(GLASS_BG));

            let header = Paragraph::new(Spans::from(glass_assets))
                .block(Block::default().borders(Borders::ALL).style(Style::default().bg(GLASS_BG).fg(GLASS_BORDER)))
                .style(Style::default().add_modifier(Modifier::BOLD));

            let main_layout = Layout::new(
                Direction::Vertical,
                vec![
                    Constraint::Percentage(10),
                    Constraint::Percentage(80),
                    Constraint::Percentage(10),
                ],
            );

            let csv_display = if let Some(file) = &app.csv_file {
                let status = if app.csv_data.is_empty() {
                    Spans::from(vec![
                        Span::styled("CSV file loaded, but no data read yet.", Style::default().fg(GLASS_TEXT)),
                    ])
                } else {
                    Spans::from(vec![
                        Span::styled(format!("Loaded: {}", app.csv_data.len()), Style::default().fg(GLASS_TEXT)),
                        Span::styled(format!(", Columns: {}", app.csv_data[0].keys().count()), Style::default().fg(GLASS_TEXT)),
                    ])
                };

                Paragraph::new(csv_display)
                    .block(Block::default().borders(Borders::ALL).style(Style::default().bg(GLASS_BG).fg(GLASS_BORDER)))
            } else {
                Paragraph::new(Spans::from(vec![
                    Span::styled("No CSV file loaded", Style::default().fg(GLASS_TEXT)),
                ]))
                .block(Block::default().borders(Borders::ALL).style(Style::default().bg(GLASS_BG).fg(GLASS_BORDER)))
            };

            let query_input = Paragraph::new(Spans::from(vec![
                Span::styled("SQL Query: ", Style::default().add_modifier(Modifier::BOLD)),
                Span::styled(&app.query, Style::default().fg(GLASS_TEXT)),
            ]))
            .block(Block::default().borders(Borders::ALL).style(Style::default().bg(GLASS_BG).fg(GLASS_BORDER)));

            let results_display = if app.results.data.is_empty() {
                Paragraph::new(Spans::from(vec![
                    Span::styled("Query results will appear here", Style::default().fg(GLASS_TEXT)),
                ]))
                .block(Block::default().borders(Borders::ALL).style(Style::default().bg(GLASS_BG).fg(GLASS_BORDER)))
            } else {
                // Results with alternating row colors
                let mut result_text = Vec::new();

                // Header row
                result_text.push(Span::styled(
                    app.results.columns.join(" | "),
                    Style::default().add_modifier(Modifier::BOLD).fg(GLASS_TEXT),
                ));

                // Data rows
                for (i, row) in app.results.data.iter().enumerate() {
                    let row_text = row.join(" | ");
                    let row_span = if i % 2 == 0 {
                        Span::styled(row_text, Style::default().fg(GLASS_TEXT))
                    } else {
                        Span::styled(row_text, Style::default().add_modifier(Modifier::REVERSED).fg(GLASS_TEXT))
                    };
                    result_text.push(row_span);
                }

                Paragraph::new(Spans::from(result_text))
                    .block(Block::default().borders(Borders::ALL).style(Style::default().bg(GLASS_BG).fg(GLASS_BORDER)))
            };

            f.render_widget(header, size);
            f.render_widget(
                main_layout,
                size,
            );

            let inner = main_layout.inner(size);
            f.render_widget(csv_display, inner[0]);
            f.render_widget(query_input, inner[1]);
            f.render_widget(results_display, inner[2]);

            // Status bar
            let status = if app.is_running {
                Span::styled("NeonQuery - Press ? for help", Style::default().fg(GLASS_TEXT))
            } else {
                Span::styled("Exiting...", Style::default().add_modifier(Modifier::BOLD).fg(NEON_HIGHLIGHT))
            };

            f.render_widget(
                Paragraph::new(Spans::from(vec![status]))
                    .style(Style::default().bg(GLASS_BG).fg(GLASS_BORDER))
                    .block(Block::default().borders(Borders::ALL)),
                size,
            );
        }).unwrap();

        // Handle events
        if let Event::Key(key) = crossterm::event::poll(0)? {
            match key.code {
                KeyCode::Char(c) => {
                    app.query.push(c);
                }
                KeyCode::Enter => {
                    app.execute_query();
                    app.query = String::new();
                }
                KeyCode::Backspace => {
                    app.query.pop();
                }
                KeyCode::Up => {
                    app.previous_query();
                }
                KeyCode::Down => {
                    app.next_query();
                }
                KeyCode::Char('q') => {
                    app.is_running = false;
                }
                KeyCode::Char('?') => {
                    show_help();
                    continue; // Don't process other events while help is shown
                }
                KeyCode::Char('l') => {
                    if let Some(file) = &app.csv_file {
                        if let Ok(_) = app.load_csv(file) {
                            // Success - nothing to show to user
                        }
                    }
                }
                KeyCode::Char('o') => {
                    let path = r#"C:\Users\<username>\Downloads\"#; // Default path
                    let mut file_path = String::from(path);

                    // Let user input custom path
                    let mut input = String::new();
                    io::stdin().read_line(&mut input).unwrap();
                    file_path.push_str(&input.trim());

                    if Path::new(&file_path).exists() {
                        if let Ok(_) = app.load_csv(&file_path) {
                            app.csv_file = Some(file_path);
                        }
                    }
                }
                _ => {}
            }
        }

        if !app.is_running {
            break;
        }

        // Small delay to prevent CPU overload
        thread::sleep(Duration::from_millis(50));
    }

    // Cleanup
    disable_raw_mode().unwrap();
    execute!(io::stdout(), LeaveAltScreen).unwrap();
    terminal.show_cursor().unwrap();
}

fn show_help() {
    let help_text = vec![
        Span::styled("NeonQuery Help", Style::default().add_modifier(Modifier::BOLD).fg(NEON_HIGHLIGHT)),
        Span::styled("=======================================", Style::default().fg(GLASS_TEXT)),
        Span::styled("Commands:", Style::default().add_modifier(Modifier::BOLD).fg(NEON_HIGHLIGHT)),
        Span::styled("  o - Load CSV file", Style::default().fg(GLASS_TEXT)),
        Span::styled("  l - Reload current CSV file", Style::default().fg(GLASS_TEXT)),
        Span::styled("  ↑/↓ - Navigate query history", Style::default().fg(GLASS_TEXT)),
        Span::styled("  ? - Show this help", Style::default().fg(GLASS_TEXT)),
        Span::styled("  q - Quit NeonQuery", Style::default().fg(GLASS_TEXT)),
        Span::styled("SQL Syntax Examples:", Style::default().add_modifier(Modifier::BOLD).fg(NEON_HIGHLIGHT)),
        Span::styled("  SELECT * FROM data WHERE column = 'value'", Style::default().fg(GLASS_TEXT)),
        Span::styled("  SELECT column1, column2 FROM data ORDER BY column1", Style::default().fg(GLASS_TEXT)),
        Span::styled("  SELECT * FROM data WHERE column LIKE '%pattern%'", Style::default().fg(GLASS_TEXT)),
    ];

    let help_terminal = Terminal::new(CrosstermBackend::new(io::stdout())).unwrap();
    help_terminal.draw(|f| {
        let size = f.size();
        let help_paragraph = Paragraph::new(Spans::from(help_text))
            .block(Block::default().borders(Borders::ALL).title("Help").style(Style::default().bg(GLASS_BG).fg(GLASS_BORDER)));

        f.render_widget(help_paragraph, size);
    }).unwrap();

    // Wait for user to close help
    loop {
        if let Event::Key(key) = crossterm::event::poll(0).unwrap() {
            if key.code == KeyCode::Char('?') || key.code == KeyCode::Esc {
                break;
            }
        }
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Neon Memory Flip</title>
  <style>
    :root {
      --neon-pink: #ff3a75;
      --neon-blue: #1e90ff;
      --neon-purple: #a226c9;
      --neon-green: #00ff88;
      --neon-orange: #ff7700;
      --neon-yellow: #ffff00;
    }

    body {
      margin: 0;
      padding: 0;
      font-family: 'Arial', sans-serif;
      background: linear-gradient(135deg, #0f0c29, #302b63, #24243e);
      color: white;
      display: flex;
      flex-direction: column;
      align-items: center;
      min-height: 100vh;
      overflow-x: hidden;
    }

    h1 {
      font-size: 2.5rem;
      margin-bottom: 1rem;
      text-shadow: 0 0 10px var(--neon-pink);
      animation: pulse 2s infinite alternate;
    }

    .game-container {
      width: 800px;
      margin: 2rem auto;
      perspective: 1000px;
    }

    .game-grid {
      display: grid;
      grid-template-columns: repeat(4, 1fr);
      gap: 1rem;
      width: 100%;
      max-width: 800px;
    }

    .card {
      position: relative;
      width: 100px;
      height: 100px;
      background: #1a1a2e;
      border-radius: 10px;
      box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
      transition: transform 0.3s;
      cursor: pointer;
      transform-style: preserve-3d;
    }

    .card.flipped {
      transform: rotateY(180deg);
    }

    .card-inner {
      position: relative;
      width: 100%;
      height: 100%;
      text-align: center;
      font-size: 2rem;
      display: flex;
      flex-direction: column;
      justify-content: center;
      align-items: center;
      transition: transform 0.6s;
      transform: translateY(-100px);
      background: linear-gradient(135deg, #1a1a2e, #2d1b69);
    }

    .card.flipped .card-inner {
      transform: translateY(0);
    }

    .card-back {
      position: absolute;
      top: 0;
      left: 0;
      width: 100%;
      height: 100%;
      background: linear-gradient(135deg, #1a1a2e, #2d1b69);
      border-radius: 10px;
      display: flex;
      justify-content: center;
      align-items: center;
      font-size: 1.5rem;
      color: #ffffff;
      box-shadow: inset 0 0 20px rgba(0, 0, 0, 0.5);
    }

    .card-front {
      position: absolute;
      top: 0;
      left: 0;
      width: 100%;
      height: 100%;
      background: linear-gradient(135deg, #1a1a2e, #2d1b69);
      border-radius: 10px;
      display: flex;
      flex-direction: column;
      justify-content: center;
      align-items: center;
      color: white;
      box-shadow: inset 0 0 20px rgba(0, 0, 0, 0.5);
    }

    .card-front .symbol {
      font-size: 3rem;
      margin-bottom: 0.5rem;
    }

    .card-front .card-value {
      font-size: 1rem;
      opacity: 0.8;
    }

    .flipped .card-back {
      transform: rotateY(180deg);
    }

    .card-match {
      background: linear-gradient(135deg, var(--neon-pink), var(--neon-blue));
      box-shadow: 0 0 30px 10px rgba(255, 255, 255, 0.3);
      transform: rotateY(180deg) scale(1.1);
    }

    .stats {
      margin-top: 2rem;
      text-align: center;
      font-size: 1.2rem;
    }

    .sound-btn {
      position: absolute;
      top: 20px;
      right: 20px;
      background: none;
      border: 2px solid var(--neon-pink);
      color: var(--neon-pink);
      padding: 8px 12px;
      border-radius: 5px;
      cursor: pointer;
      font-size: 1rem;
      transition: all 0.3s;
    }

    .sound-btn:hover {
      background: var(--neon-pink);
      color: white;
    }

    .sound-btn.off {
      border-color: #555;
      color: #555;
    }

    .sound-btn.off:hover {
      background: none;
    }

    .restart-btn {
      margin-top: 1rem;
      padding: 0.8rem 1.5rem;
      background: linear-gradient(135deg, var(--neon-pink), var(--neon-purple));
      border: none;
      border-radius: 5px;
      color: white;
      font-size: 1rem;
      cursor: pointer;
      transition: all 0.3s;
      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.2);
    }

    .restart-btn:hover {
      transform: translateY(-2px);
      box-shadow: 0 6px 8px rgba(0, 0, 0, 0.3);
    }

    .highscore {
      margin-top: 1rem;
      padding: 0.5rem;
      background: rgba(0, 0, 0, 0.3);
      border-radius: 5px;
      font-size: 1rem;
    }

    @keyframes pulse {
      0% {
        text-shadow: 0 0 5px var(--neon-pink);
      }
      100% {
        text-shadow: 0 0 20px var(--neon-pink);
      }
    }

    @keyframes explode {
      0% {
        transform: scale(1);
      }
      50% {
        transform: scale(1.2);
      }
      100% {
        transform: scale(1);
      }
    }

    .particle {
      position: absolute;
      width: 5px;
      height: 5px;
      border-radius: 50%;
      box-shadow: 0 0 10px 5px var(--neon-pink);
      pointer-events: none;
    }
  </style>
</head>
<body>
  <button class="sound-btn" id="soundToggle">🔇 SOUND</button>
  <h1>NEON MEMORY FLIP</h1>
  <div class="game-container">
    <div class="game-grid" id="gameGrid"></div>
  </div>
  <div class="stats">
    <p>Moves: <span id="moves">0</span></p>
    <button class="restart-btn" id="restartBtn">NEW GAME</button>
    <div class="highscore">Highscore: <span id="highscore">0</span></div>
  </div>

  <audio id="flipSound" src="data:audio/wav;base64,UklGRh8gIlNOCISKZCg2IAAAAAQAAAAABAAEAKglhbGxvc3QsIG5vYm94ZCBpbnN0YW5jZXMgaW4gdGhlIGltYWdlcyBpcyBwcmVmaXggeW91ciBib2FyZGF5IG1vZGUgYmFzZWQgd2lkZ2V0cywgc2FsdA=="></audio>
  <audio id="matchSound" src="data:audio/wav;base64,UklGRiFwXAZnNISIwAEASQAAAAQAAAAYAAEAKgVsYW5kYXJ5IGJlYXJlcyBzZWxlY3RzIGlzIHVzdG9tYXRlcyBpbiBhZ21hIGZhc2hzb24gd2lkZ2V0cyBpcyBwcmVmaXggdGhlIGZpbHRlZCBnb29kZQ=="></audio>
  <audio id="winSound" src="data:audio/wav;base64,UklGRmwvMFVvNISIwAEASQAAAAQAAAAYAAEAKgVuZW50b3RoIGJlYXJlcyBzZWxlY3RzIGlzIHVzdG9tYXRlcyBpbiBhZ21hIGZhc2hzb24gd2lkZ2V0cyBpcyBwcmVmaXggdGhlIGZpbHRlZCBnb29kZQ=="></audio>

  <script>
    document.addEventListener('DOMContentLoaded', () => {
      const gameGrid = document.getElementById('gameGrid');
      const movesDisplay = document.getElementById('moves');
      const highscoreDisplay = document.getElementById('highscore');
      const restartBtn = document.getElementById('restartBtn');
      const soundToggle = document.getElementById('soundToggle');

      let gameState = {
        cards: [],
        flippedCards: [],
        moves: 0,
        highscore: localStorage.getItem('neonMemoryHighscore') || 0,
        soundOn: true
      };

      // Initialize the game
      initGame();
      renderHighscore();
      updateSoundButton();

      // Event listeners
      restartBtn.addEventListener('click', initGame);
      soundToggle.addEventListener('click', toggleSound);

      // Functions
      function initGame() {
        gameState.cards = createCards();
        gameState.flippedCards = [];
        gameState.moves = 0;
        movesDisplay.textContent = gameState.moves;
        renderCards();
        shuffleCards();
      }

      function createCards() {
        const symbols = ['✦', '△', '☺', '🌕', '⚡', '💎', '🔥', '🌟'];
        const cards = [];

        // Create pairs of cards
        for (let i = 0; i < symbols.length; i++) {
          cards.push({
            id: i,
            symbol: symbols[i],
            flipped: false,
            matched: false
          });
          cards.push({
            id: i,
            symbol: symbols[i],
            flipped: false,
            matched: false
          });
        }

        return cards;
      }

      function shuffleCards() {
        // Fisher-Yates shuffle algorithm
        for (let i = gameState.cards.length - 1; i > 0; i--) {
          const j = Math.floor(Math.random() * (i + 1));
          [gameState.cards[i], gameState.cards[j]] = [gameState.cards[j], gameState.cards[i]];
        }
      }

      function renderCards() {
        gameGrid.innerHTML = '';

        gameState.cards.forEach((card, index) => {
          const cardElement = document.createElement('div');
          cardElement.className = 'card';
          if (card.flipped) cardElement.classList.add('flipped');
          if (card.matched) cardElement.classList.add('card-match');

          cardElement.innerHTML = `
            <div class="card-back">
              <div class="back-symbol">🚀</div>
            </div>
            <div class="card-front">
              <div class="symbol">${card.symbol}</div>
              <div class="card-value">${index + 1}</div>
            </div>
          `;

          cardElement.addEventListener('click', () => handleCardClick(index));
          gameGrid.appendChild(cardElement);
        });
      }

      function handleCardClick(index) {
        if (gameState.flippedCards.length === 2 || gameState.cards[index].flipped || gameState.cards[index].matched) {
          return;
        }

        gameState.moves++;
        movesDisplay.textContent = gameState.moves;

        gameState.cards[index].flipped = true;
        gameState.flippedCards.push(index);

        renderCards();

        if (gameState.flippedCards.length === 2) {
          setTimeout(checkForMatch, 300);
        }
      }

      function checkForMatch() {
        const [index1, index2] = gameState.flippedCards;

        if (gameState.cards[index1].symbol === gameState.cards[index2].symbol) {
          gameState.cards[index1].matched = true;
          gameState.cards[index2].matched = true;

          if (gameState.soundOn) {
            document.getElementById('matchSound').play();
          }

          // Create explosion particles
          createExplosion(index1);
          createExplosion(index2);

          gameState.flippedCards = [];
          renderCards();

          checkWinCondition();

          return;
        }

        // If no match, flip cards back
        setTimeout(() => {
          gameState.cards[index1].flipped = false;
          gameState.cards[index2].flipped = false;
          gameState.flippedCards = [];

          if (gameState.soundOn) {
            document.getElementById('flipSound').play();
          }

          renderCards();
        }, 500);
      }

      function createExplosion(index) {
        const cardElement = gameGrid.children[index];
        const rect = cardElement.getBoundingClientRect();
        const centerX = rect.left + rect.width / 2;
        const centerY = rect.top + rect.height / 2;

        for (let i = 0; i < 30; i++) {
          const particle = document.createElement('div');
          particle.className = 'particle';

          // Random color based on the card's color
          const hue = Math.floor(Math.random() * 60) + 200;
          particle.style.background = `hsl(${hue}, 100%, 50%)`;
          particle.style.boxShadow = `0 0 10px 5px hsl(${hue}, 100%, 50%)`;

          // Random position around the center
          const angle = Math.random() * Math.PI * 2;
          const distance = Math.random() * 30 + 20;
          const x = Math.cos(angle) * distance;
          const y = Math.sin(angle) * distance;

          particle.style.left = `${centerX + x}px`;
          particle.style.top = `${centerY + y}px`;

          // Random animation duration
          const duration = Math.random() * 0.5 + 0.5;
          particle.style.animation = `explode ${duration}s linear`;

          document.body.appendChild(particle);

          // Remove particle after animation
          setTimeout(() => {
            particle.remove();
          }, duration * 1000);
        }
      }

      function checkWinCondition() {
        const allMatched = gameState.cards.every(card => card.matched);

        if (allMatched) {
          if (gameState.moves < gameState.highscore) {
            gameState.highscore = gameState.moves;
            localStorage.setItem('neonMemoryHighscore', gameState.highscore);
          }
          renderHighscore();

          if (gameState.soundOn) {
            document.getElementById('winSound').play();
          }

          setTimeout(() => {
            alert(`You won in ${gameState.moves} moves! New highscore: ${gameState.highscore}`);
          }, 500);
        }
      }

      function renderHighscore() {
        highscoreDisplay.textContent = gameState.highscore;
      }

      function toggleSound() {
        gameState.soundOn = !gameState.soundOn;
        updateSoundButton();
      }

      function updateSoundButton() {
        if (gameState.soundOn) {
          soundToggle.textContent = '🔇 SOUND';
          soundToggle.classList.remove('off');
        } else {
          soundToggle.textContent = '🔊 SOUND';
          soundToggle.classList.add('off');
        }
      }
    });
  </script>
</body>
</html>

#!/usr/bin/env python3
"""
NeonCipher - File Encryption Utility with ASCII Art Visualization
"""

import os
import sys
import argparse
import hashlib
import json
import time
from typing import Tuple, Optional, List
import terminal_colors  # Using a hypothetical package for dark mode colors

# ASCII Art Animation for encryption/decryption
ASCII_ANIMATIONS = {
    'encryption': [
        "  __  __  __  __  __  ",
        " / / / / / / / / / / ",
        "/ / / / / / / / / / /",
        "/ / / / / / / / / / /",
        "-------I-------I------"
    ],
    'decryption': [
        "  __  __  __  __  __  ",
        " / / / / / / / / / / ",
        "/ / / / / / / / / / /",
        "/ / / / / / / / / / /",
        "  -------O-----O-----"
    ]
}

def dark_mode_colors():
    """Return dark mode terminal colors for ASCII art"""
    return {
        'reset': terminal_colors.dark.RESET,
        'cyan': terminal_colors.dark.CYAN,
        'yellow': terminal_colors.dark.YELLOW,
        'green': terminal_colors.dark.GREEN,
        'blue': terminal_colors.dark.BLUE,
        'magenta': terminal_colors.dark.MAGENTA
    }

def visualize_operation(operation: str, duration: float) -> None:
    """Visualize encryption/decryption with animated ASCII art"""
    colors = dark_mode_colors()
    frames = ASCII_ANIMATIONS[operation]
    width = len(frames[0])

    for i in range(len(frames)):
        # Colorize the ASCII art
        colored_frame = (
            f"{colors['cyan']}{frames[i][:width//2]}{colors['reset']}"
            f"{colors['yellow']}{frames[i][width//2:]}{colors['reset']}"
        )
        print(f"\r{colored_frame}", end="", flush=True)
        time.sleep(duration / len(frames))

    print()  # New line after animation

def generate_key(password: str) -> str:
    """Generate a consistent encryption key from password using SHA-256"""
    return hashlib.sha256(password.encode()).hexdigest()

def xor_encrypt_decrypt(data: bytes, key: str) -> bytes:
    """XOR encryption/decryption using the key"""
    key_bytes = key.encode()
    return bytes([data[i] ^ key_bytes[i % len(key_bytes)] for i in range(len(data))])

def process_file(filepath: str, operation: str, key: str) -> Tuple[str, str]:
    """Process file for encryption or decryption"""
    start_time = time.time()

    if operation == 'encrypt':
        with open(filepath, 'rb') as f:
            data = f.read()
        encrypted = xor_encrypt_decrypt(data, key)
        encrypted_str = encrypted.hex()
        encrypted_file = filepath + '.neoncipher'
        with open(encrypted_file, 'w') as f:
            f.write(encrypted_str)
        return encrypted_file, f"Encrypted {os.path.basename(filepath)} to {encrypted_file}"
    else:
        encrypted_file = filepath
        if not encrypted_file.endswith('.neoncipher'):
            encrypted_file = filepath + '.neoncipher'
        if not os.path.exists(encrypted_file):
            raise FileNotFoundError(f"Encrypted file {encrypted_file} not found")

        with open(encrypted_file, 'r') as f:
            encrypted_str = f.read()
        encrypted = bytes.fromhex(encrypted_str)
        decrypted = xor_encrypt_decrypt(encrypted, key)
        with open(filepath, 'wb') as f:
            f.write(decrypted)
        return filepath, f"Decrypted to {os.path.basename(filepath)}"

def main():
    """Main function with argument parsing and execution"""
    parser = argparse.ArgumentParser(
        description="NeonCipher - File encryption with ASCII art visualization",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )
    parser.add_argument('file', help='File to encrypt or decrypt')
    parser.add_argument('--password', required=True, help='Encryption password')
    parser.add_argument('--operation', choices=['encrypt', 'decrypt'], default='encrypt',
                       help='Operation to perform')
    parser.add_argument('--dark', action='store_true', help='Enable dark mode ASCII art')
    args = parser.parse_args()

    try:
        key = generate_key(args.password)
        operation = args.operation
        print(f"Starting {operation.capitalize()}...")
        visualize_operation(operation, 2.0)
        result_file, message = process_file(args.file, operation, key)
        print(message)
        if operation == 'encrypt':
            print(f"Encryption complete. Password: '{args.password}'")
        else:
            print(f"Decryption complete. Password: '{args.password}'")

    except Exception as e:
        print(f"\nError: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()

<?php
/**
 * Plugin Name: Morpheus Login
 * Description: Custom login page designer with smooth CSS animations and real-time preview.
 * Version: 1.0.0
 * Author: Ailey (AI)
 * License: GPLv2 or later
 * Text Domain: morpheus-login
 */

if (!defined('ABSPATH')) {
    exit; // Exit if accessed directly.
}

class Morpheus_Login {

    private $base_path;
    private $assets_path;
    private $preview_nonce;
    private $preview_data;

    public function __construct() {
        $this->base_path = plugin_dir_path(__FILE__);
        $this->assets_path = $this->base_path . 'assets/';

        // Register assets and dependencies.
        add_action('admin_enqueue_scripts', array($this, 'enqueue_assets'));

        // Custom login page.
        add_filter('login_headerurl', array($this, 'custom_login_header'));
        add_action('login_head', array($this, 'custom_login_head'));
        add_action('login_form', array($this, 'custom_login_form'));

        // Settings.
        add_action('admin_menu', array($this, 'add_settings_page'));
        add_action('admin_init', array($this, 'register_settings'));

        // AJAX for real-time preview.
        add_action('wp_ajax_morpheus_login_preview', array($this, 'ajax_preview_handler'));
        add_action('wp_ajax_nopriv_morpheus_login_preview', array($this, 'ajax_preview_handler'));

        // Initialize preview nonce.
        $this->preview_nonce = wp_nonce_field('morpheus_login_preview_nonce', 'preview_nonce', false, false);
    }

    // Enqueue CSS and JS.
    public function enqueue_assets($hook) {
        if ($hook !== 'toplevel_page_morpheus-login-settings') {
            return;
        }

        wp_enqueue_style(
            'morpheus-login-admin',
            plugins_url('css/admin.css', __FILE__),
            array(),
            filemtime($this->assets_path . 'css/admin.css')
        );

        wp_enqueue_script(
            'morpheus-login-admin',
            plugins_url('js/admin.js', __FILE__),
            array('jquery'),
            filemtime($this->assets_path . 'js/admin.js'),
            true
        );

        wp_localize_script('morpheus-login-admin', 'morpheus_login', array(
            'ajaxurl' => admin_url('admin-ajax.php'),
            'nonce' => wp_create_nonce('morpheus_login_preview_nonce')
        ));
    }

    // Custom login header.
    public function custom_login_header() {
        return site_url('/');
    }

    // Custom login head (styles and meta).
    public function custom_login_head() {
        $settings = get_option('morpheus_login_settings');
        $bg_url = !empty($settings['bg_image']) ? esc_url($settings['bg_image']) : plugins_url('images/default-bg.jpg', __FILE__);

        echo '<style type="text/css">';
        echo 'html, body { background: url(' . $bg_url . ') no-repeat center center fixed; background-size: cover; }';
        echo '.login { animation: fadeIn 0.5s ease-in-out; }';
        echo '@keyframes fadeIn { from { opacity: 0; transform: translateY(20px); } to { opacity: 1; transform: translateY(0); } }';
        echo '</style>';
        echo '<meta name="viewport" content="width=device-width, initial-scale=1.0">';
    }

    // Custom login form with morphing animations.
    public function custom_login_form() {
        $settings = get_option('morpheus_login_settings');

        echo '<div class="morpheus-login-container">';
        echo '<div class="morpheus-login-card" style="background: ' . esc_attr($settings['card_bg']) . '; border: ' . esc_attr($settings['card_border']) . ';';

        // Morphing animation styles.
        echo 'animation: morphIn 0.8s cubic-bezier(0.2, 0.8, 0.2, 1);';
        echo '</div>';

        echo '<form name="loginform" id="loginform" class="morpheus-form" method="post" action="' . esc_url(site_url('/wp-login.php', 'login_post')) . '">';
        echo wp_signon_form(false);

        // Submit button with animation.
        echo '<button type="submit" id="wp-submit" class="morpheus-submit" style="background: ' . esc_attr($settings['btn_bg']) . '; color: ' . esc_attr($settings['btn_text']) . '; border: ' . esc_attr($settings['btn_border']) . ';">';
        echo '<span class="morpheus-submit-text">' . esc_html__('Log In', 'morpheus-login') . '</span>';
        echo '<span class="morpheus-submit-ripple"></span>';
        echo '</button>';
        echo '</form>';
        echo '</div>';
    }

    // Add settings page.
    public function add_settings_page() {
        add_options_page(
            'Morpheus Login Settings',
            'Morpheus Login',
            'manage_options',
            'morpheus-login-settings',
            array($this, 'render_settings_page')
        );
    }

    // Register settings.
    public function register_settings() {
        register_setting('morpheus_login', 'morpheus_login_settings', array($this, 'sanitize_settings'));

        add_settings_section(
            'morpheus_login_settings_section',
            'Login Page Styling',
            array($this, 'print_settings_section_info'),
            'morpheus_login'
        );

        // Background image.
        add_settings_field(
            'bg_image',
            'Background Image',
            array($this, 'render_bg_image_field'),
            'morpheus_login',
            'morpheus_login_settings_section'
        );

        // Card styling.
        add_settings_field(
            'card_bg',
            'Card Background',
            array($this, 'render_card_bg_field'),
            'morpheus_login',
            'morpheus_login_settings_section'
        );

        add_settings_field(
            'card_border',
            'Card Border',
            array($this, 'render_card_border_field'),
            'morpheus_login',
            'morpheus_login_settings_section'
        );

        // Button styling.
        add_settings_field(
            'btn_bg',
            'Button Background',
            array($this, 'render_btn_bg_field'),
            'morpheus_login',
            'morpheus_login_settings_section'
        );

        add_settings_field(
            'btn_text',
            'Button Text Color',
            array($this, 'render_btn_text_field'),
            'morpheus_login',
            'morpheus_login_settings_section'
        );

        add_settings_field(
            'btn_border',
            'Button Border',
            array($this, 'render_btn_border_field'),
            'morpheus_login',
            'morpheus_login_settings_section'
        );

        // Animation speed.
        add_settings_field(
            'animation_speed',
            'Animation Speed (ms)',
            array($this, 'render_animation_speed_field'),
            'morpheus_login',
            'morpheus_login_settings_section'
        );
    }

    // Sanitize settings.
    public function sanitize_settings($input) {
        $new_input = array();

        $new_input['bg_image'] = sanitize_url($input['bg_image']);
        $new_input['card_bg'] = sanitize_text_field($input['card_bg']);
        $new_input['card_border'] = sanitize_text_field($input['card_border']);
        $new_input['btn_bg'] = sanitize_text_field($input['btn_bg']);
        $new_input['btn_text'] = sanitize_text_field($input['btn_text']);
        $new_input['btn_border'] = sanitize_text_field($input['btn_border']);
        $new_input['animation_speed'] = absint($input['animation_speed']);

        return $new_input;
    }

    // Print section info.
    public function print_settings_section_info() {
        echo '<p>' . esc_html__('Customize your WordPress login page with smooth animations and full control over styling.', 'morpheus-login') . '</p>';
    }

    // Render background image field.
    public function render_bg_image_field() {
        $settings = get_option('morpheus_login_settings');
        $bg_url = !empty($settings['bg_image']) ? esc_url($settings['bg_image']) : plugins_url('images/default-bg.jpg', __FILE__);

        echo '<input type="url" id="bg_image" name="morpheus_login_settings[bg_image]" value="' . esc_url($settings['bg_image']) . '" class="regular-text" placeholder="https://example.com/image.jpg">';
        echo '<div id="bg_preview" class="bg-preview" style="background-image: url(' . $bg_url . ');"></div>';
    }

    // Render card background field.
    public function render_card_bg_field() {
        $settings = get_option('morpheus_login_settings');
        $value = !empty($settings['card_bg']) ? $settings['card_bg'] : '#ffffff';

        echo '<input type="text" id="card_bg" name="morpheus_login_settings[card_bg]" value="' . esc_attr($value) . '" class="color-picker regular-text" data-default-color="' . esc_attr($value) . '">';
    }

    // Render card border field.
    public function render_card_border_field() {
        $settings = get_option('morpheus_login_settings');
        $value = !empty($settings['card_border']) ? $settings['card_border'] : '1px solid #ddd';

        echo '<input type="text" id="card_border" name="morpheus_login_settings[card_border]" value="' . esc_attr($value) . '" class="regular-text">';
    }

    // Render button background field.
    public function render_btn_bg_field() {
        $settings = get_option('morpheus_login_settings');
        $value = !empty($settings['btn_bg']) ? $settings['btn_bg'] : '#333';

        echo '<input type="text" id="btn_bg" name="morpheus_login_settings[btn_bg]" value="' . esc_attr($value) . '" class="color-picker regular-text" data-default-color="' . esc_attr($value) . '">';
    }

    // Render button text color field.
    public function render_btn_text_field() {
        $settings = get_option('morpheus_login_settings');
        $value = !empty($settings['btn_text']) ? $settings['btn_text'] : '#fff';

        echo '<input type="text" id="btn_text" name="morpheus_login_settings[btn_text]" value="' . esc_attr($value) . '" class="color-picker regular-text" data-default-color="' . esc_attr($value) . '">';
    }

    // Render button border field.
    public function render_btn_border_field() {
        $settings = get_option('morpheus_login_settings');
        $value = !empty($settings['btn_border']) ? $settings['btn_border'] : 'none';

        echo '<input type="text" id="btn_border" name="morpheus_login_settings[btn_border]" value="' . esc_attr($value) . '" class="regular-text">';
    }

    // Render animation speed field.
    public function render_animation_speed_field() {
        $settings = get_option('morpheus_login_settings');
        $value = !empty($settings['animation_speed']) ? $settings['animation_speed'] : 800;

        echo '<input type="number" id="animation_speed" name="morpheus_login_settings[animation_speed]" value="' . esc_attr($value) . '" min="200" max="2000" class="small-text">';
    }

    // Render settings page.
    public function render_settings_page() {
        $settings = get_option('morpheus_login_settings', array());
        $this->preview_data = $settings;

        // Ensure required keys exist.
        $defaults = array(
            'bg_image' => plugins_url('images/default-bg.jpg', __FILE__),
            'card_bg' => '#ffffff',
            'card_border' => '1px solid #ddd',
            'btn_bg' => '#333',
            'btn_text' => '#fff',
            'btn_border' => 'none',
            'animation_speed' => 800
        );

        $settings = wp_parse_args($settings, $defaults);
        update_option('morpheus_login_settings', $settings);

        echo '<div class="wrap">';
        echo '<h1>' . esc_html__('Morpheus Login', 'morpheus-login') . '</h1>';
        echo '<p>' . esc_html__('Design your WordPress login page with smooth animations and full styling control.', 'morpheus-login') . '</p>';

        echo '<h2 class="nav-tab-wrapper">';
        echo '<a href="#preview" class="nav-tab active">' . esc_html__('Live Preview', 'morpheus-login') . '</a>';
        echo '<a href="#settings" class="nav-tab">' . esc_html__('Settings', 'morpheus-login') . '</a>';
        echo '</h2>';

        echo '<div id="preview" class="morpheus-preview-tab">';
        echo '<div class="morpheus-preview-frame">';
        echo '<div class="morpheus-preview-login">';
        echo '<h3>' . esc_html__('Preview: Morpheus Login', 'morpheus-login') . '</h3>';
        echo '<div class="morpheus-preview-form">';
        echo '<form method="post">';
        echo '<p><input type="email" placeholder="Email" class="morpheus-preview-input"></p>';
        echo '<p><input type="password" placeholder="Password" class="morpheus-preview-input"></p>';
        echo '<p><button type="submit" class="morpheus-preview-btn">' . esc_html__('Log In', 'morpheus-login') . '</button></p>';
        echo '</form>';
        echo '</div>';
        echo '</div>';
        echo '</div>';
        echo '</div>';

        echo '<div id="settings" class="morpheus-settings-tab">';
        echo '<form method="post" action="options.php">';
        echo $this->preview_nonce;
        settings_fields('morpheus_login');
        do_settings_sections('morpheus_login');
        submit_button(esc_html__('Save Settings', 'morpheus-login'));
        echo '</form>';
        echo '</div>';
        echo '</div>';
    }

    // AJAX handler for real-time preview.
    public function ajax_preview_handler() {
        check_ajax_referer('morpheus_login_preview_nonce', 'nonce');

        $settings = array(
            'bg_image' => sanitize_url($_POST['bg_image']),
            'card_bg' => sanitize_text_field($_POST['card_bg']),
            'card_border' => sanitize_text_field($_POST['card_border']),
            'btn_bg' => sanitize_text_field($_POST['btn_bg']),
            'btn_text' => sanitize_text_field($_POST['btn_text']),
            'btn_border' => sanitize_text_field($_POST['btn_border']),
            'animation_speed' => absint($_POST['animation_speed'])
        );

        $this->preview_data = $settings;

        echo '<div class="morpheus-preview-frame">';
        echo '<div class="morpheus-preview-login" style="background: ' . esc_attr($settings['card_bg']) . '; border: ' . esc_attr($settings['card_border']) . '; animation-duration: ' . absint($settings['animation_speed']) . 'ms;">';
        echo '<h3>' . esc_html__('Preview: Morpheus Login', 'morpheus-login') . '</h3>';
        echo '<div class="morpheus-preview-form">';
        echo '<form method="post">';
        echo '<p><input type="email" placeholder="Email" class="morpheus-preview-input" style="background: rgba(255,255,255,0.8); border: 1px solid #ccc;"></p>';
        echo '<p><input type="password" placeholder="Password" class="morpheus-preview-input" style="background: rgba(255,255,255,0.8); border: 1px solid #ccc;"></p>';
        echo '<p><button type="submit" class="morpheus-preview-btn" style="background: ' . esc_attr($settings['btn_bg']) . '; color: ' . esc_attr($settings['btn_text']) . '; border: ' . esc_attr($settings['btn_border']) . ';">';
        echo '<span class="morpheus-submit-text">' . esc_html__('Log In', 'morpheus-login') . '</span>';
        echo '</button></p>';
        echo '</form>';
        echo '</div>';
        echo '</div>';
        echo '</div>';

        wp_die();
    }
}

new Morpheus_Login();

#!/usr/bin/env python3
"""Ailey's Glitch Art Generator - Turns images into psychedelic digital noise art."""

import os
import sys
import random
from typing import Tuple, Optional, List
from pathlib import Path
from PIL import Image, ImageFilter, ImageDraw, ImageOps

class GlitchArtGenerator:
    """Core class for generating glitch art from input images."""

    def __init__(self, seed: Optional[int] = None):
        """Initialize the generator with optional random seed."""
        if seed is not None:
            random.seed(seed)
        self._effects = [
            self._apply_pixel_glitch,
            self._apply_color_swap,
            self._apply_QR_distortion,
            self._apply_geometric_shift,
            self._apply_scanshift,
            self._apply_vertical_lines,
            self._apply_horizontal_lines,
            self._apply_chroma_shift,
            self._apply_blue_screen,
            self._apply_interlace
        ]

    def process_image(self, input_path: str, output_path: str, intensity: float = 0.7) -> None:
        """
        Process an image through the glitch art pipeline.

        Args:
            input_path: Path to input image
            output_path: Path to save output
            intensity: Controls how extreme the glitches are (0.0-1.0)
        """
        if not os.path.exists(input_path):
            raise FileNotFoundError(f"Input image not found: {input_path}")

        try:
            with Image.open(input_path) as img:
                glitched = img.copy()
                effects = random.sample(self._effects, k=random.randint(2, 5))

                for effect in effects:
                    if random.random() < intensity:
                        glitched = effect(glitched)

                glitched.save(output_path)
                print(f"✨ Glitch art saved to: {output_path}")
        except Exception as e:
            print(f"❌ Error processing image: {str(e)}", file=sys.stderr)
            raise

    def _apply_pixel_glitch(self, img: Image.Image) -> Image.Image:
        """Randomly corrupt pixels to create digital noise."""
        width, height = img.size
        draw = ImageDraw.Draw(img)
        pixels = img.load()

        for x in range(width):
            for y in range(height):
                if random.random() > 0.8:  # 20% chance of corruption
                    r = random.randint(0, 255)
                    g = random.randint(0, 255)
                    b = random.randint(0, 255)
                    pixels[x, y] = (r, g, b)
        return img

    def _apply_color_swap(self, img: Image.Image) -> Image.Image:
        """Swap RGB channels for a color shift effect."""
        pixels = img.load()
        width, height = img.size

        for x in range(width):
            for y in range(height):
                r, g, b = pixels[x, y][:3]
                if random.random() > 0.7:  # 30% chance of swap
                    pixels[x, y] = (b, r, g)
        return img

    def _apply_QR_distortion(self, img: Image.Image) -> Image.Image:
        """Simulate QR code distortion effect."""
        if random.random() > 0.3:  # 70% chance to skip
            return img

        # Create QR-like pattern overlay
        overlay = Image.new('RGB', img.size, (255, 255, 255))
        draw = ImageDraw.Draw(overlay)

        grid_size = max(1, img.width // 10)
        for x in range(0, img.width, grid_size):
            for y in range(0, img.height, grid_size):
                if random.random() > 0.5:
                    draw.rectangle([x, y, x + grid_size, y + grid_size], fill=(0, 0, 0))

        # Combine with original
        img = Image.alpha_composite(img.convert('RGBA'), overlay.convert('RGBA'))
        return img

    def _apply_geometric_shift(self, img: Image.Image) -> Image.Image:
        """Shift image pixels in random geometric patterns."""
        width, height = img.size
        draw = ImageDraw.Draw(img)

        # Random shift amount
        shift_x = random.randint(-20, 20)
        shift_y = random.randint(-20, 20)

        # Create shifted version
        shifted = img.transform(
            (width, height),
            Image.AFFINE,
            (1, 0, shift_x, 0, 1, shift_y),
            fillcolor=(0, 0, 0)
        )

        # Blend with original
        alpha = Image.new('L', img.size, 128)
        result = Image.composite(img, shifted, alpha)
        return result

    def _apply_scanshift(self, img: Image.Image) -> Image.Image:
        """Simulate old CRT television scan lines."""
        scan_lines = Image.new('L', img.size, 0)
        draw = ImageDraw.Draw(scan_lines)

        for y in range(0, img.height, 3):
            draw.line([(0, y), (img.width, y)], fill=255, width=1)

        # Apply to image
        img = Image.composite(img, scan_lines.convert('RGB'), scan_lines)
        return img

    def _apply_vertical_lines(self, img: Image.Image) -> Image.Image:
        """Add vertical glitch lines."""
        width, height = img.size
        draw = ImageDraw.Draw(img)

        for x in range(0, width, random.randint(10, 30)):
            if random.random() > 0.5:
                draw.line([(x, 0), (x, height)], fill=(random.randint(100, 255), 0, 0), width=1)

        return img

    def _apply_horizontal_lines(self, img: Image.Image) -> Image.Image:
        """Add horizontal glitch lines."""
        width, height = img.size
        draw = ImageDraw.Draw(img)

        for y in range(0, height, random.randint(10, 30)):
            if random.random() > 0.5:
                draw.line([(0, y), (width, y)], fill=(0, 0, random.randint(100, 255)), width=1)

        return img

    def _apply_chroma_shift(self, img: Image.Image) -> Image.Image:
        """Shift hue values to create psychedelic effect."""
        pixels = img.load()
        width, height = img.size

        for x in range(width):
            for y in range(height):
                r, g, b = pixels[x, y]
                if random.random() > 0.7:
                    # Random hue shift
                    shift = random.randint(-50, 50)
                    r = max(0, min(255, r + shift))
                    g = max(0, min(255, g + shift))
                    b = max(0, min(255, b + shift))
                    pixels[x, y] = (r, g, b)
        return img

    def _apply_blue_screen(self, img: Image.Image) -> Image.Image:
        """Apply blue screen chroma key effect."""
        # Create blue screen pattern
        blue_screen = Image.new('RGB', img.size, (50, 100, 255))
        draw = ImageDraw.Draw(blue_screen)

        # Add some distortion
        for x in range(0, img.width, 20):
            for y in range(0, img.height, 20):
                if random.random() > 0.5:
                    draw.rectangle([x, y, x + 20, y + 20], fill=(0, 0, 255))

        # Blend with original
        alpha = Image.new('L', img.size, 128)
        result = Image.composite(blue_screen, img, alpha)
        return result

    def _apply_interlace(self, img: Image.Image) -> Image.Image:
        """Simulate interlaced video effect."""
        width, height = img.size
        interlaced = Image.new('RGB', (width, height))

        for y in range(height):
            for x in range(width):
                if y % 2 == 0:  # Even lines
                    interlaced.putpixel((x, y), img.getpixel((x, y//2 * 2)))
                else:  # Odd lines (shifted)
                    interlaced.putpixel((x, y), img.getpixel((x, (y+1)//2 * 2)))

        return interlaced

def main():
    """Command-line interface for the Glitch Art Generator."""
    import argparse

    parser = argparse.ArgumentParser(
        description="Ailey's Glitch Art Generator - Create psychedelic digital noise art from images."
    )
    parser.add_argument('input', help='Input image path')
    parser.add_argument('output', help='Output image path')
    parser.add_argument('--intensity', type=float, default=0.7,
                        help='Glitch intensity (0.0-1.0, default: 0.7)')
    parser.add_argument('--seed', type=int, default=None,
                        help='Random seed for reproducible results')

    args = parser.parse_args()

    try:
        generator = GlitchArtGenerator(seed=args.seed)
        generator.process_image(args.input, args.output, intensity=args.intensity)
    except Exception as e:
        print(f"❌ Error: {str(e)}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

```kotlin
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Keyboard
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.window.TouchTargetSize
import androidx.compose.ui.window.serialization.LocalWindowSizeSerializer
import java.math.BigDecimal
import java.math.RoundingMode
import kotlin.math.pow

@Composable
fun MathsparkApp() {
    val history = remember { mutableListOf<String>() }
    val windowSizeSerializer = LocalWindowSizeSerializer.current
    var expression by remember { mutableStateOf("") }
    val keyboardController = LocalSoftwareKeyboardController.current
    var lastResult by remember { mutableStateOf("0") }
    var lastError by remember { mutableStateOf("") }

    MaterialTheme {
        Surface(
            modifier = Modifier.fillMaxSize(),
            color = MaterialTheme.colorScheme.background
        ) {
            Column(
                modifier = Modifier.fillMaxSize(),
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                HistoryDisplay(history)
                CalculatorDisplay(expression, lastResult, lastError)
                KeyboardController { closeKeyboard = { keyboardController?.hide() } }
                CalculatorButtons(
                    onNumberClick = { digit ->
                        expression += digit
                    },
                    onOperatorClick = { operator ->
                        if (expression.isNotEmpty() && !operator.isNone()) {
                            expression += operator
                        }
                    },
                    onFunctionClick = { function ->
                        when (function) {
                            "x²" -> expression = sqrt(expression).toString()
                            "1/x" -> expression = inverse(expression).toString()
                            "x!" -> expression = factorial(expression).toString()
                            "C" -> expression = ""
                            "⌫" -> expression = expression.dropLastOrNull() ?: ""
                            "=" -> {
                                try {
                                    val result = evaluate(expression)
                                    lastResult = result.toString()
                                    history.add("$expression = $result")
                                    expression = result.toString()
                                } catch (e: Exception) {
                                    lastError = "Error: ${e.message}"
                                }
                            }
                        }
                    }
                )
            }
        }
    }
}

@Composable
fun HistoryDisplay(history: List<String>) {
    val scrollState = rememberScrollState()
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .height(100.dp)
            .padding(horizontal = 16.dp)
    ) {
        Text(
            text = "History",
            style = MaterialTheme.typography.titleMedium,
            modifier = Modifier.align(Alignment.Start)
        )
        Spacer(modifier = Modifier.height(8.dp))
        VerticalScrollbar(
            adapter = rememberScrollStateAdapter(scrollState),
            modifier = Modifier.align(Alignment.End)
        )
        LazyColumn(
            modifier = Modifier
                .fillMaxHeight()
                .weight(1f)
        ) {
            items(history) { item ->
                Text(
                    text = item,
                    style = MaterialTheme.typography.bodyMedium,
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(vertical = 4.dp)
                )
            }
        }
    }
}

@Composable
fun CalculatorDisplay(
    expression: String,
    result: String,
    error: String
) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp)
            .height(150.dp),
        horizontalAlignment = Alignment.End,
        verticalArrangement = Arrangement.Bottom
    ) {
        Text(
            text = expression,
            style = MaterialTheme.typography.displayMedium,
            color = MaterialTheme.colorScheme.onBackground,
            modifier = Modifier.align(Alignment.End)
        )
        Spacer(modifier = Modifier.height(8.dp))
        if (error.isNotEmpty()) {
            Text(
                text = error,
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.error,
                modifier = Modifier.align(Alignment.End)
            )
        } else {
            Text(
                text = result,
                style = MaterialTheme.typography.headlineMedium,
                color = MaterialTheme.colorScheme.primary,
                modifier = Modifier.align(Alignment.End)
            )
        }
    }
}

@Composable
fun KeyboardController(onClose: () -> Unit) {
    Text(
        text = "Press ENTER to calculate or SPACE to clear",
        style = MaterialTheme.typography.bodySmall,
        modifier = Modifier
            .padding(horizontal = 16.dp)
            .align(Alignment.CenterHorizontally)
    )
}

@Composable
fun CalculatorButtons(
    onNumberClick: (String) -> Unit,
    onOperatorClick: (String) -> Unit,
    onFunctionClick: (String) -> Unit
) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp)
            .weight(1f)
    ) {
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            CalculatorButton("C", onFunctionClick, "Clear")
            CalculatorButton("⌫", onFunctionClick, "Backspace")
            CalculatorButton("x²", onFunctionClick, "Square")
            CalculatorButton("1/x", onFunctionClick, "Reciprocal")
        }
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            CalculatorButton("x!", onFunctionClick, "Factorial")
            CalculatorButton("(", onOperatorClick, "Parentheses")
            CalculatorButton(")", onOperatorClick, "Parentheses")
            CalculatorButton("÷", onOperatorClick, "Divide")
        }
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.animation.core.*
import androidx.compose.foundation.*
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.unitconverter.ui.theme.UnitConverterTheme
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.expandVertically
import androidx.compose.animation.fadeIn
import androidx.compose.animation.shrinkVertically
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.text.style.TextOverflow
import com.example.unitconverter.data.UnitConverterData
import com.example.unitconverter.ui.theme.Purple200
import com.example.unitconverter.ui.theme.Teal200
import kotlinx.coroutines.launch

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            UnitConverterTheme {
                Surface(
                    modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background
                ) {
                    UnitConverterApp()
                }
            }
        }
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun UnitConverterApp() {
    var inputValue by remember { mutableStateOf("") }
    var resultValue by remember { mutableStateOf("") }
    var selectedUnits by remember { mutableStateOf(UnitConverterData.allUnits.first()) }
    var isAnimating by remember { mutableStateOf(false) }
    val scope = rememberCoroutineScope()

    val animateVisible = remember { Animatable(0f) }
    val animateResult = remember { Animatable(0f) }
    val animateFloating = remember { Animatable(0f) }

    val floatingEmoji = when (selectedUnits.emoji) {
        "🌡️" -> "🔥"
        "ℹ️" -> "💧"
        "📏" -> "🎨"
        "🔋" -> "⚡"
        else -> "✨"
    }

    UnitConverterTheme {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .padding(16.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            Text(
                text = "Unit Converter 🎉",
                style = MaterialTheme.typography.headlineMedium,
                color = MaterialTheme.colorScheme.primary,
                fontWeight = FontWeight.Bold,
                modifier = Modifier.padding(vertical = 16.dp)
            )

            AnimatedVisibility(
                visible = !isAnimating,
                enter = expandVertically() + fadeIn(),
                exit = shrinkVertically() + fadeIn()
            ) {
                UnitConverterScreen(
                    inputValue = inputValue,
                    onInputChange = { inputValue = it },
                    selectedUnits = selectedUnits,
                    onUnitChange = { selectedUnits = it },
                    onConvert = {
                        scope.launch {
                            isAnimating = true
                            animateVisible.animateTo(1f, animationSpec = tween(300))
                            animateResult.animateTo(1f, animationSpec = tween(300))
                            animateFloating.animateTo(100f, animationSpec = tween(500))

                            resultValue = UnitConverterData.convert(
                                inputValue.toDoubleOrNull() ?: 0.0,
                                selectedUnits
                            ).toString()

                            // Wait for animation to complete
                            animateFloating.animateTo(0f, animationSpec = tween(300))
                            animateResult.animateTo(0f, animationSpec = tween(300))
                            animateVisible.animateTo(0f, animationSpec = tween(300))
                            isAnimating = false
                        }
                    }
                )
            }

            Box(
                modifier = Modifier
                    .fillMaxWidth()
                    .height(animateFloating.value.dp)
                    .align(Alignment.CenterHorizontally),
                contentAlignment = Alignment.Center
            ) {
                AnimatedContent(
                    targetState = floatingEmoji,
                    transitionSpec = {
                        tween(300).using(
                            initialTargetState = floatingEmoji,
                            crossfadeWith = floatingEmoji
                        )
                    }
                ) { target ->
                    Text(
                        text = target,
                        fontSize = 48.sp,
                        color = Color.Black,
                        modifier = Modifier
                            .clip(CircleShape)
                            .background(Purple200)
                            .padding(8.dp)
                    )
                }
            }
        }
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun UnitConverterScreen(
    inputValue: String,
    onInputChange: (String) -> Unit,
    selectedUnits: UnitConverterData.UnitInfo,
    onUnitChange: (UnitConverterData.UnitInfo) -> Unit,
    onConvert: () -> Unit
) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(horizontal = 16.dp),
        shape = RoundedCornerShape(16.dp),
        elevation = CardDefaults.cardElevation(4.dp)
    ) {
        Column(
            modifier = Modifier.padding(16.dp),
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            TextField(
                value = inputValue,
                onValueChange = onInputChange,
                label = { Text("Enter value") },
                keyboardOptions = KeyboardOptions.Default.copy(
                    keyboardType = KeyboardType.Number
                ),
                singleLine = true,
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(vertical = 8.dp),
                colors = TextFieldDefaults.colors(
                    focusedContainerColor = Teal200.copy(alpha = 0.2f),
                    unfocusedContainerColor = Teal200.copy(alpha = 0.1f)
                ),
                shape = RoundedCornerShape(8.dp)
            )

            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(vertical = 8.dp),
                horizontalArrangement = Arrangement.Center
            ) {
                Chip(
                    onClick = { onUnitChange(selectedUnits) },
                    label = { Text("${selectedUnits.name} (${selectedUnits.fromUnit})") },
                    leading = {
                        Icon(
                            imageVector = ImageVectorBuilder(
                                name = "unit-icon",
                                defaultWidth = Dp(20f),
                                defaultHeight = Dp(20f),
                                viewportWidth = 20f,
                                viewportHeight = 20f
                            ).apply {
                                path(
                                    fill = SolidColor(MaterialTheme.colorScheme.primary),
                                    stroke = SolidColor(MaterialTheme.colorScheme.primary),
                                    strokeWidth = 1f
                                ) {
                                    moveTo(10f, 10f)
                                    lineTo(10f, 10f)
                                    // Simple placeholder icon - would be replaced with actual vector
                                }
                            },
                            contentDescription = null,
                            modifier = Modifier.size(24.dp)
                        )
                    },
                    shape = RoundedCornerShape(8.dp),
                    colors = ChipDefaults.chipColors(
                        containerColor = MaterialTheme.colorScheme.primaryContainer,
                        labelColor = MaterialTheme.colorScheme.onPrimaryContainer
                    )
                )

                Spacer(modifier = Modifier.width(8.dp))

                Text(
                    text = selectedUnits.emoji,
                    fontSize = 24.sp,
                    color = MaterialTheme.colorScheme.primary
                )
            }

            Button(
                onClick = onConvert,
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(vertical = 16.dp),
                shape = RoundedCornerShape(8.dp),
                colors = ButtonDefaults.buttonColors(
                    containerColor = MaterialTheme.colorScheme.primary,
                    contentColor = MaterialTheme.colorScheme.onPrimary
                )
            ) {
                Text("Convert! 🚀")
            }

            Spacer(modifier = Modifier.height(16.dp))

            Column(
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text(
                    text = "Result:",
                    fontWeight = FontWeight.Bold,
                    color = MaterialTheme.colorScheme.secondary
                )

                Box(
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(vertical = 8.dp)
                ) {
                    AnimatedVisibility(
                        visible = animateResult.value > 0f,
                        enter = fadeIn() + expandVertically(),
                        exit = fadeOut() + shrinkVertically()
                    ) {
                        Text(
                            text = resultValue,
                            fontSize = 20.sp,
                            fontWeight = FontWeight.Bold,
                            color = MaterialTheme.colorScheme.onSurfaceVariant,
                            textAlign = TextAlign.Center,
                            maxLines = 1,
                            overflow = TextOverflow.Ellipsis
                        )
                    }
                }

                Text(
                    text = "${selectedUnits.toUnit} (${selectedUnits.name})",
                    fontSize = 16.sp,
                    color = MaterialTheme.colorScheme.onSurface
                )
            }
        }
    }
}

@Preview(showBackground = true)
@Composable
fun UnitConverterPreview() {
    UnitConverterTheme {
        UnitConverterApp()
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Linq;

[RequireComponent(typeof(Button))]
public class InteractiveMenuItem : MonoBehaviour
{
    [SerializeField] private float pulseSpeed = 1.5f;
    [SerializeField] private float maxScale = 1.2f;
    [SerializeField] private float minScale = 0.9f;
    [SerializeField] private Color idleColor = Color.white;
    [SerializeField] private Color hoverColor = Color.cyan;
    [SerializeField] private Color activeColor = Color.magenta;
    [SerializeField] private ConfettiParticleSystem confettiPrefab;
    [SerializeField] private float confettiDuration = 2.5f;

    private Button button;
    private Image image;
    private float originalScale;
    private bool isActive;

    private void Awake()
    {
        button = GetComponent<Button>();
        image = GetComponent<Image>();

        if (image == null)
        {
            Debug.LogWarning("InteractiveMenuItem requires an Image component for visual effects");
            enabled = false;
            return;
        }

        originalScale = transform.localScale.x;
        button.onClick.AddListener(OnMenuItemSelected);
        button.onHover.AddListener(OnMenuItemHover);
        button.onHoverEnd.AddListener(OnMenuItemHoverEnd);
    }

    private void Update()
    {
        if (!isActive) return;

        // Pulsing animation
        float scaleFactor = Mathf.PingPong(Time.time * pulseSpeed, maxScale - minScale) + minScale;
        transform.localScale = new Vector3(scaleFactor, scaleFactor, 1);

        // Color cycling
        float colorTime = Time.time * pulseSpeed;
        image.color = Color.Lerp(activeColor, hoverColor, Mathf.Abs(Mathf.Sin(colorTime * 2f)));
    }

    private void OnMenuItemHover()
    {
        image.color = hoverColor;
    }

    private void OnMenuItemHoverEnd()
    {
        image.color = idleColor;
    }

    private void OnMenuItemSelected()
    {
        isActive = true;
        PlayConfettiEffect();

        // Optional: You could trigger other game events here
        // Debug.Log("Menu item selected: " + gameObject.name);
    }

    private void PlayConfettiEffect()
    {
        if (confettiPrefab != null)
        {
            // Create confetti at the center of the button's screen position
            Vector3 confettiPos = Camera.main.ScreenToWorldPoint(new Vector3(
                transform.position.x,
                transform.position.y,
                Camera.main.nearClipPlane + 0.1f
            ));

            var confetti = Instantiate(confettiPrefab, confettiPos, Quaternion.identity, transform);
            confetti.Play(confettiDuration);

            // Auto-destroy after animation completes
            Destroy(confetti.gameObject, confettiDuration + 0.1f);
        }
    }

    private void OnDestroy()
    {
        if (button != null)
        {
            button.onClick.RemoveListener(OnMenuItemSelected);
            button.onHover.RemoveListener(OnMenuItemHover);
            button.onHoverEnd.RemoveListener(OnMenuItemHoverEnd);
        }
    }
}

[RequireComponent(typeof(ParticleSystem))]
public class ConfettiParticleSystem : MonoBehaviour
{
    private ParticleSystem particleSystem;

    private void Awake()
    {
        particleSystem = GetComponent<ParticleSystem>();
    }

    public void Play(float duration)
    {
        if (particleSystem != null)
        {
            var emission = particleSystem.emission;
            emission.enabled = true;
            particleSystem.Play();
            particleSystem.main.duration = duration;
        }
    }

    public void Stop()
    {
        if (particleSystem != null)
        {
            var emission = particleSystem.emission;
            emission.enabled = false;
            particleSystem.Stop();
        }
    }
}

// RPG Maker MZ Dynamic AI Behavior Simulator
// Simulates NPC behavior including wandering, interaction, and emotional state

const { EventEmitter } = require('events');
const { v4: uuidv4 } = require('uuid');

class RPGMAISEmitter extends EventEmitter {
  constructor() {
    super();
    this.npcs = new Map();
  }

  addNPC(name, x, y, mapId) {
    const id = uuidv4();
    this.npcs.set(id, {
      id,
      name,
      x,
      y,
      mapId,
      emotionalState: 'neutral',
      currentTask: null,
      wanderTarget: null,
      lastInteraction: null
    });
    this.emit('npcAdded', id);
    return id;
  }

  updateNPC(id, x, y) {
    const npc = this.npcs.get(id);
    if (npc) {
      npc.x = x;
      npc.y = y;
      this.emit('npcMoved', id, x, y);
    }
  }

  interact(id, playerId, interactionType) {
    const npc = this.npcs.get(id);
    if (npc) {
      npc.emotionalState = interactionType === 'positive' ? 'happy' : 'angry';
      npc.lastInteraction = {
        playerId,
        type: interactionType,
        timestamp: Date.now()
      };
      this.emit('npcInteracted', id, playerId, interactionType);
    }
  }

  getNPCStatus(id) {
    const npc = this.npcs.get(id);
    if (npc) {
      return {
        id: npc.id,
        name: npc.name,
        position: { x: npc.x, y: npc.y },
        mapId: npc.mapId,
        emotionalState: npc.emotionalState,
        lastInteraction: npc.lastInteraction
      };
    }
    return null;
  }

  simulateFrame() {
    for (const [id, npc] of this.npcs) {
      // Wander behavior
      if (!npc.wanderTarget) {
        npc.wanderTarget = {
          x: npc.x + (Math.random() > 0.5 ? 1 : -1) * 3,
          y: npc.y + (Math.random() > 0.5 ? 1 : -1) * 3
        };
      }

      // Move toward wander target
      const dx = npc.wanderTarget.x - npc.x;
      const dy = npc.wanderTarget.y - npc.y;
      const distance = Math.sqrt(dx * dx + dy * dy);

      if (distance < 1) {
        npc.wanderTarget = null;
      } else {
        npc.x += (dx / distance) * 0.5;
        npc.y += (dy / distance) * 0.5;
        this.emit('npcMoved', id, npc.x, npc.y);
      }

      // Emotional state decay
      if (npc.emotionalState !== 'neutral') {
        if (Math.random() < 0.05) { // 5% chance to reset state each frame
          npc.emotionalState = 'neutral';
        }
      }
    }
  }
}

// Simulation setup
const rpgAI = new RPGMAISEmitter();

// Example NPCs
const merchantId = rpgAI.addNPC('Traveling Merchant', 10, 10, 1);
const guardId = rpgAI.addNPC('Town Guard', 15, 15, 1);
const wandererId = rpgAI.addNPC('Lost Wanderer', 5, 5, 1);

// Example interactions
setTimeout(() => {
  rpgAI.interact(merchantId, 'player1', 'positive');
}, 1000);

setTimeout(() => {
  rpgAI.interact(guardId, 'player1', 'negative');
}, 2000);

// Simulation loop
setInterval(() => {
  rpgAI.simulateFrame();
}, 16); // ~60fps

// Status check every 5 seconds
setInterval(() => {
  console.log('Current NPC States:');
  for (const id of rpgAI.npcs.keys()) {
    const status = rpgAI.getNPCStatus(id);
    if (status) {
      console.log(`- ${status.name}: ${status.emotionalState} (${status.position.x}, ${status.position.y})`);
      if (status.lastInteraction) {
        console.log(`  Last interaction: ${status.lastInteraction.type} with player ${status.lastInteraction.playerId}`);
      }
    }
  }
  console.log('------------------');
}, 5000);

// Export for potential RPG Maker MZ integration
module.exports = RPGMAISEmitter;