V .4.1

static/js/encryption.js

@@ -1,10 +1,21 @@
-// encryption.js
+/**
+ * Encryption module.
+ * Handles cryptographic operations using Web Crypto API.
+ * Implements AES-GCM encryption with PBKDF2 key derivation.
+ */
 
+// ===== Constants =====
+const SALT_LENGTH = 16;
+const IV_LENGTH = 12;
+const PBKDF2_ITERATIONS = 200_000;
+const KEY_LENGTH = 256;
+
+// ===== Key Derivation =====
 /**
  * Derives an AES-GCM key from a password using PBKDF2.
  * @param {string} password - User-supplied password.
  * @param {Uint8Array} salt - Randomly generated salt.
- * @returns {Promise<CryptoKey>}
+ * @returns {Promise<CryptoKey>} - Derived cryptographic key.
  */
 export async function deriveKey(password, salt) {
     const encoder = new TextEncoder();
@@ -20,16 +31,17 @@ export async function deriveKey(password, salt) {
         {
             name: 'PBKDF2',
             salt,
-            iterations: 200_000,
+            iterations: PBKDF2_ITERATIONS,
             hash: 'SHA-256'
         },
         keyMaterial,
-        { name: 'AES-GCM', length: 256 },
+        { name: 'AES-GCM', length: KEY_LENGTH },
         false,
         ['encrypt', 'decrypt']
     );
 }
 
+// ===== Encryption =====
 /**
  * Encrypts a message using AES-GCM with a derived key.
  * @param {string} message - Plaintext message to encrypt.
@@ -38,12 +50,16 @@ export async function deriveKey(password, salt) {
  */
 export async function encryptAdvanced(message, password) {
     const encoder = new TextEncoder();
-    const salt = crypto.getRandomValues(new Uint8Array(16));
-    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
+    const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
     const key = await deriveKey(password, salt);
     const encoded = encoder.encode(message);
 
-    const ciphertext = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, encoded);
+    const ciphertext = await crypto.subtle.encrypt(
+        { name: 'AES-GCM', iv },
+        key,
+        encoded
+    );
 
     const output = new Uint8Array(salt.length + iv.length + ciphertext.byteLength);
     output.set(salt);
@@ -53,6 +69,7 @@ export async function encryptAdvanced(message, password) {
     return btoa(String.fromCharCode(...output));
 }
 
+// ===== Decryption =====
 /**
  * Decrypts an AES-GCM encrypted string.
  * @param {string} encryptedData - Base64-encoded ciphertext.
@@ -64,9 +81,9 @@ export async function decryptAdvanced(encryptedData, password) {
         atob(encryptedData).split('').map(c => c.charCodeAt(0))
     );
 
-    const salt = encrypted.slice(0, 16);
-    const iv = encrypted.slice(16, 28);
-    const ciphertext = encrypted.slice(28);
+    const salt = encrypted.slice(0, SALT_LENGTH);
+    const iv = encrypted.slice(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+    const ciphertext = encrypted.slice(SALT_LENGTH + IV_LENGTH);
     const key = await deriveKey(password, salt);
 
     const decrypted = await crypto.subtle.decrypt(
@@ -78,8 +95,9 @@ export async function decryptAdvanced(encryptedData, password) {
     return new TextDecoder().decode(decrypted);
 }
 
+// ===== Module Initialization =====
 /**
- * Optional init logging for module diagnostics.
+ * Initializes the encryption module and logs its status.
  */
 export function setupEncryption() {
     console.log('[Encryption] Module loaded');

static/js/fileops.js

@@ -1,92 +1,119 @@
-// fileops.js
-
-import { encryptAdvanced, decryptAdvanced } from './encryption.js';
-
 /**
- * Encrypts the selected file and triggers download of the encrypted version.
- * @param {HTMLInputElement} fileInput - The input element of type 'file'.
- * @param {string} password - Password for encryption.
+ * File operations module.
+ * Handles file encryption and decryption operations.
  */
-export function encryptFile(fileInput, password) {
-    if (!fileInput.files.length) {
-        alert("Please select a file!");
-        return;
-    }
 
+// ===== Constants =====
+const CHUNK_SIZE = 1024 * 1024; // 1MB chunks
+
+// ===== Public Interface =====
+export async function encryptFile(fileInput, password) {
     const file = fileInput.files[0];
-    const reader = new FileReader();
+    if (!file) return;
 
-    reader.onload = async (e) => {
-        const rawBytes = new Uint8Array(e.target.result);
-        const base64 = btoa(String.fromCharCode(...rawBytes));
-        const encrypted = await encryptAdvanced(base64, password);
-        downloadFile(encrypted, file.name + ".enc");
-    };
-
-    reader.readAsArrayBuffer(file);
+    try {
+        const encryptedChunks = await processFile(file, password, true);
+        downloadEncryptedFile(encryptedChunks, file.name);
+    } catch (error) {
+        alert("Error encrypting file: " + error.message);
+    }
 }
 
-/**
- * Decrypts the selected encrypted file and triggers download of the original.
- * @param {HTMLInputElement} fileInput - The input element of type 'file'.
- * @param {string} password - Password for decryption.
- */
-export function decryptFile(fileInput, password) {
-    if (!fileInput.files.length) {
-        alert("Please select a file!");
-        return;
+export async function decryptFile(fileInput, password) {
+    const file = fileInput.files[0];
+    if (!file) return;
+
+    try {
+        const decryptedChunks = await processFile(file, password, false);
+        downloadDecryptedFile(decryptedChunks, file.name);
+    } catch (error) {
+        alert("Error decrypting file: " + error.message);
+    }
+}
+
+// ===== File Processing =====
+async function processFile(file, password, isEncrypt) {
+    const chunks = [];
+    const totalChunks = Math.ceil(file.size / CHUNK_SIZE);
+    let processedChunks = 0;
+
+    for (let start = 0; start < file.size; start += CHUNK_SIZE) {
+        const chunk = file.slice(start, start + CHUNK_SIZE);
+        const arrayBuffer = await chunk.arrayBuffer();
+        const uint8Array = new Uint8Array(arrayBuffer);
+        
+        const processedChunk = await processChunk(uint8Array, password, isEncrypt);
+        chunks.push(processedChunk);
+        
+        processedChunks++;
+        updateProgress(processedChunks, totalChunks);
     }
 
-    const file = fileInput.files[0];
-    const reader = new FileReader();
+    return chunks;
+}
 
-    reader.onload = async (e) => {
-        try {
-            const encryptedText = e.target.result;
-            const base64Decrypted = await decryptAdvanced(encryptedText, password);
-            const byteArray = new Uint8Array(
-                [...atob(base64Decrypted)].map(c => c.charCodeAt(0))
-            );
-            downloadFileBinary(byteArray, file.name.replace(/\.enc$/, ''));
-        } catch (err) {
-            console.error("[Decryption Error]", err);
-            alert("Decryption failed: wrong password or corrupted file.");
+async function processChunk(data, password, isEncrypt) {
+    const payload = {
+        "encryption-type": "advanced",
+        operation: isEncrypt ? "encrypt" : "decrypt",
+        message: Array.from(data).join(','),
+        password: password
+    };
+
+    const response = await fetch("/", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const result = await response.json();
+    return new Uint8Array(result.result.split(',').map(Number));
+}
+
+// ===== File Download =====
+function downloadEncryptedFile(chunks, originalName) {
+    const blob = new Blob(chunks, { type: 'application/octet-stream' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = originalName + '.encrypted';
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}
+
+function downloadDecryptedFile(chunks, originalName) {
+    const blob = new Blob(chunks, { type: 'application/octet-stream' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = originalName.replace('.encrypted', '');
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}
+
+// ===== Progress Tracking =====
+function updateProgress(processed, total) {
+    const progressBar = document.getElementById("file-progress");
+    const progressText = document.getElementById("file-progress-text");
+    
+    if (progressBar && progressText) {
+        const percent = Math.round((processed / total) * 100);
+        progressBar.style.width = percent + "%";
+        progressText.textContent = `Processing: ${percent}%`;
+        
+        if (processed === total) {
+            setTimeout(() => {
+                progressBar.style.width = "0%";
+                progressText.textContent = "";
+            }, 1000);
         }
-    };
-
-    reader.readAsText(file);
-}
-
-/**
- * Downloads a text-based file (encrypted string).
- * @param {string} content - The file content to download.
- * @param {string} filename - Desired name for the downloaded file.
- */
-function downloadFile(content, filename) {
-    const blob = new Blob([content], { type: "application/octet-stream" });
-    const url = URL.createObjectURL(blob);
-
-    const a = document.createElement("a");
-    a.href = url;
-    a.download = filename;
-    a.click();
-
-    URL.revokeObjectURL(url);
-}
-
-/**
- * Downloads a binary file (Uint8Array).
- * @param {Uint8Array} byteArray - The binary content.
- * @param {string} filename - Desired name for the downloaded file.
- */
-function downloadFileBinary(byteArray, filename) {
-    const blob = new Blob([byteArray], { type: "application/octet-stream" });
-    const url = URL.createObjectURL(blob);
-
-    const a = document.createElement("a");
-    a.href = url;
-    a.download = filename;
-    a.click();
-
-    URL.revokeObjectURL(url);
+    }
 }

static/js/main.js

@@ -1,11 +1,12 @@
-// main.js
+/**
+ * Main application entry point.
+ * Initializes UI and game components when the DOM is loaded.
+ */
 
 import { setupUI } from './ui.js';
 import { setupGame } from './pacman.js';
 
-/**
- * Initialize UI and game once the DOM is fully loaded.
- */
+// Initialize application when DOM is fully loaded
 window.addEventListener("DOMContentLoaded", () => {
     setupUI();
     setupGame();

static/js/pacman.js

@@ -1,47 +1,28 @@
-// pacman.js
+/**
+ * Pacman game module.
+ * Handles game logic, rendering, and user interaction.
+ */
 
+// ===== Game Constants =====
+const PACMAN_SPEED = 40;
+const ENEMY_SPEED = 20;
+const CELL_SIZE = 40;
+const DOT_SIZE = 5;
+
+// ===== Game State =====
+let canvas, ctx, pacman, enemy, walls, dots, score;
+let cols, rows, randSeed, gameInterval;
+
+// ===== Public Interface =====
 export function setupGame() {
     console.log('[PacMan] Game module loaded.');
-
     window.startPacman = startPacman;
     window.exitGame = exitGame;
 }
 
-// ====== Game Constants & State ======
-let canvas, ctx, pacman, enemy, walls, dots, score;
-let pacmanSpeed = 40,
-    enemySpeed = 20,
-    cellSize = 40,
-    dotSize = 5,
-    cols, rows, randSeed, gameInterval;
-
-// ====== Game Initialization ======
-
 export function startPacman() {
-    canvas = document.getElementById("pacmanCanvas");
-    ctx = canvas.getContext("2d");
-
-    cols = Math.floor(canvas.width / cellSize);
-    rows = Math.floor(canvas.height / cellSize);
-    walls = [];
-    dots = [];
-    score = 0;
-
-    clearInterval(gameInterval);
-    const seedSource = document.getElementById("password")?.value || "pacman";
-    randSeed = [...seedSource].reduce((s, c) => s + c.charCodeAt(0), 0);
-
-
-    generateWalls();
-    generateDots();
-
-    pacman = spawn();
-    do { enemy = spawn(); } while (enemy.x === pacman.x && enemy.y === pacman.y);
-
-    pacman.dx = pacman.dy = 0;
-    document.addEventListener("keydown", movePacman);
-
-    gameInterval = setInterval(gameLoop, 150);
+    initializeGame();
+    setupGameLoop();
 }
 
 export function stopPacman() {
@@ -61,8 +42,39 @@ export function exitGame() {
     document.getElementById("encoding-section").style.display = "block";
 }
 
-// ====== Game Setup Helpers ======
+// ===== Game Initialization =====
+function initializeGame() {
+    canvas = document.getElementById("pacmanCanvas");
+    ctx = canvas.getContext("2d");
 
+    cols = Math.floor(canvas.width / CELL_SIZE);
+    rows = Math.floor(canvas.height / CELL_SIZE);
+    walls = [];
+    dots = [];
+    score = 0;
+
+    clearInterval(gameInterval);
+    
+    // Get seed from generated password or use default
+    const passwordField = document.getElementById("generated-password");
+    const seedSource = passwordField?.value || "pacman";
+    randSeed = [...seedSource].reduce((s, c) => s + c.charCodeAt(0), 0);
+
+    generateWalls();
+    generateDots();
+
+    pacman = spawn();
+    do { enemy = spawn(); } while (enemy.x === pacman.x && enemy.y === pacman.y);
+
+    pacman.dx = pacman.dy = 0;
+    document.addEventListener("keydown", movePacman);
+}
+
+function setupGameLoop() {
+    gameInterval = setInterval(gameLoop, 150);
+}
+
+// ===== Game Setup Helpers =====
 function spawn() {
     const options = [];
     for (let c = 1; c < cols - 1; c++) {
@@ -80,9 +92,9 @@ function spawn() {
     }
     const s = options[Math.floor(rand() * options.length)];
     return {
-        x: s.c * cellSize + cellSize / 2,
-        y: s.r * cellSize + cellSize / 2,
-        size: cellSize / 2 - 5,
+        x: s.c * CELL_SIZE + CELL_SIZE / 2,
+        y: s.r * CELL_SIZE + CELL_SIZE / 2,
+        size: CELL_SIZE / 2 - 5,
         dx: 0,
         dy: 0
     };
@@ -94,6 +106,7 @@ function rand() {
 }
 
 function generateWalls() {
+    // First pass: generate initial walls
     for (let c = 0; c < cols; c++) {
         for (let r = 0; r < rows; r++) {
             if (c === 0 || r === 0 || c === cols - 1 || r === rows - 1 || rand() < 0.2) {
@@ -101,6 +114,25 @@ function generateWalls() {
             }
         }
     }
+
+    // Second pass: check for enclosed spaces
+    for (let c = 1; c < cols - 1; c++) {
+        for (let r = 1; r < rows - 1; r++) {
+            // Skip if already a wall
+            if (walls.some(w => w.c === c && w.r === r)) continue;
+
+            // Check all four sides
+            const hasWallAbove = walls.some(w => w.c === c && w.r === r - 1);
+            const hasWallBelow = walls.some(w => w.c === c && w.r === r + 1);
+            const hasWallLeft = walls.some(w => w.c === c - 1 && w.r === r);
+            const hasWallRight = walls.some(w => w.c === c + 1 && w.r === r);
+
+            // If all sides are walls, make this spot a wall too
+            if (hasWallAbove && hasWallBelow && hasWallLeft && hasWallRight) {
+                walls.push({ c, r });
+            }
+        }
+    }
 }
 
 function generateDots() {
@@ -120,8 +152,7 @@ function generateDots() {
     }
 }
 
-// ====== Game Loop & Drawing ======
-
+// ===== Game Loop & Rendering =====
 function gameLoop() {
     ctx.clearRect(0, 0, canvas.width, canvas.height);
     drawWalls();
@@ -137,7 +168,7 @@ function gameLoop() {
 function drawWalls() {
     ctx.fillStyle = "blue";
     walls.forEach(w => {
-        ctx.fillRect(w.c * cellSize, w.r * cellSize, cellSize, cellSize);
+        ctx.fillRect(w.c * CELL_SIZE, w.r * CELL_SIZE, CELL_SIZE, CELL_SIZE);
     });
 }
 
@@ -151,7 +182,10 @@ function drawChar(ch, color) {
 function drawScore() {
     ctx.fillStyle = "white";
     ctx.font = "20px Poppins";
-    ctx.fillText("Score: " + score, 10, 25);
+    ctx.textAlign = "left";
+    // Add padding to prevent clipping
+    const padding = 10;
+    ctx.fillText("Score: " + score, padding, 25);
 }
 
 function checkGameOver() {
@@ -167,17 +201,16 @@ function checkGameOver() {
     }
 }
 
-// ====== Movement Logic ======
-
+// ===== Movement Logic =====
 function movePacman(e) {
     const k = e.key;
     if (!["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(k)) return;
     e.preventDefault();
 
-    if (k === "ArrowUp") { pacman.dx = 0; pacman.dy = -pacmanSpeed; }
-    if (k === "ArrowDown") { pacman.dx = 0; pacman.dy = pacmanSpeed; }
-    if (k === "ArrowLeft") { pacman.dx = -pacmanSpeed; pacman.dy = 0; }
-    if (k === "ArrowRight") { pacman.dx = pacmanSpeed; pacman.dy = 0; }
+    if (k === "ArrowUp") { pacman.dx = 0; pacman.dy = -PACMAN_SPEED; }
+    if (k === "ArrowDown") { pacman.dx = 0; pacman.dy = PACMAN_SPEED; }
+    if (k === "ArrowLeft") { pacman.dx = -PACMAN_SPEED; pacman.dy = 0; }
+    if (k === "ArrowRight") { pacman.dx = PACMAN_SPEED; pacman.dy = 0; }
 }
 
 function moveChar(ch) {
@@ -191,7 +224,7 @@ function moveChar(ch) {
 
 function moveEnemy() {
     const options = [];
-    const moves = [[enemySpeed, 0], [-enemySpeed, 0], [0, enemySpeed], [0, -enemySpeed]];
+    const moves = [[ENEMY_SPEED, 0], [-ENEMY_SPEED, 0], [0, ENEMY_SPEED], [0, -ENEMY_SPEED]];
 
     moves.forEach(([dx, dy]) => {
         const nx = enemy.x + dx;
@@ -225,8 +258,8 @@ function willCollide(x, y, size) {
     const top = y - size, bottom = y + size;
 
     return walls.some(w => {
-        const wx1 = w.c * cellSize, wy1 = w.r * cellSize;
-        const wx2 = wx1 + cellSize, wy2 = wy1 + cellSize;
+        const wx1 = w.c * CELL_SIZE, wy1 = w.r * CELL_SIZE;
+        const wx2 = wx1 + CELL_SIZE, wy2 = wy1 + CELL_SIZE;
         return right > wx1 && left < wx2 && bottom > wy1 && top < wy2;
     });
 }
@@ -235,8 +268,8 @@ function eatDots() {
     const chompSound = document.getElementById("chomp-sound");
 
     dots = dots.filter(d => {
-        const dx = d.c * cellSize + cellSize / 2;
-        const dy = d.r * cellSize + cellSize / 2;
+        const dx = d.c * CELL_SIZE + CELL_SIZE / 2;
+        const dy = d.r * CELL_SIZE + CELL_SIZE / 2;
 
         if (Math.abs(pacman.x - dx) < pacman.size && Math.abs(pacman.y - dy) < pacman.size) {
             score++;
@@ -253,10 +286,11 @@ function eatDots() {
     ctx.fillStyle = "white";
     dots.forEach(d => {
         ctx.beginPath();
-        ctx.arc(d.c * cellSize + cellSize / 2, d.r * cellSize + cellSize / 2, dotSize, 0, Math.PI * 2);
+        ctx.arc(d.c * CELL_SIZE + CELL_SIZE / 2, d.r * CELL_SIZE + CELL_SIZE / 2, DOT_SIZE, 0, Math.PI * 2);
         ctx.fill();
     });
 }
 
+// ===== Global Functions =====
 window.resetGame = resetGame;
 window.exitGame = exitGame;

static/js/ui.js

@@ -1,72 +1,99 @@
-// ui.js
+/**
+ * UI management module.
+ * Handles user interface interactions and form handling.
+ */
+
 import { encryptFile, decryptFile } from './fileops.js';
 
-/**
- * Initialize all UI functionality after DOM is loaded
- */
+// ===== UI Initialization =====
 export function setupUI() {
-    toggleEncryptionOptions();
-    toggleInputMode();
+    // Set initial state of remove button to hidden
+    const removeBtn = document.getElementById("remove-file-btn");
+    if (removeBtn) {
+        removeBtn.style.display = "none";
+    }
+    
+    initializeEventListeners();
+}
 
-    const encryptionTypeEl = document.getElementById("encryption-type");
-    const inputTextEl = document.getElementById("input-text");
-    const formEl = document.getElementById("crypto-form");
-    const removeFileBtn = document.getElementById("remove-file-btn");
-    const clearAllBtn = document.getElementById("clear-all-btn");
-    const generateBtn = document.getElementById("generate-btn");
-    const copyPasswordBtn = document.getElementById("copy-btn");
-    const copyOutputBtn = document.getElementById("copy-output-btn");
-    const toggleSwitch = document.getElementById("operation-toggle");
-    const copyShareBtn = document.getElementById("copy-share-btn");
-    const shareLink = document.getElementById("share-link");
+// ===== Event Listeners =====
+function initializeEventListeners() {
+    const elements = {
+        encryptionType: document.getElementById("encryption-type"),
+        inputText: document.getElementById("input-text"),
+        form: document.getElementById("crypto-form"),
+        removeFileBtn: document.getElementById("remove-file-btn"),
+        clearAllBtn: document.getElementById("clear-all-btn"),
+        generateBtn: document.getElementById("generate-btn"),
+        copyPasswordBtn: document.getElementById("copy-btn"),
+        copyOutputBtn: document.getElementById("copy-output-btn"),
+        toggleSwitch: document.getElementById("operation-toggle"),
+        copyShareBtn: document.getElementById("copy-share-btn"),
+        shareLink: document.getElementById("share-link")
+    };
 
-    if (
-        encryptionTypeEl && inputTextEl && formEl && removeFileBtn &&
-        clearAllBtn && generateBtn && copyPasswordBtn && toggleSwitch
-    ) {
-        encryptionTypeEl.addEventListener("change", toggleEncryptionOptions);
-        inputTextEl.addEventListener("input", () => {
-            toggleInputMode();
-            checkForPacman();
-        });
-        formEl.addEventListener("submit", handleSubmit);
-        removeFileBtn.addEventListener("click", removeFile);
-        clearAllBtn.addEventListener("click", clearAll);
-        generateBtn.addEventListener("click", generateRandomPassword);
-        copyPasswordBtn.addEventListener("click", () => copyToClipboard("generated-password", "password-copy-feedback"));
-        copyOutputBtn?.addEventListener("click", () => copyToClipboard("output-text", "output-copy-feedback"));
-        toggleSwitch.addEventListener("change", updateToggleLabels);
-
-        const copySharedLinkBtn = document.getElementById("copy-shared-link");
-        const sharedLinkEl = document.getElementById("shared-link");
-
-        if (copySharedLinkBtn && sharedLinkEl) {
-            copySharedLinkBtn.addEventListener("click", () => {
-                navigator.clipboard.writeText(sharedLinkEl.textContent.trim()).then(() => {
-                    const feedback = document.getElementById("shared-link-feedback");
-                    if (feedback) {
-                        feedback.classList.remove("hidden");
-                        feedback.classList.add("show");
-
-                        setTimeout(() => {
-                            feedback.classList.remove("show");
-                            feedback.classList.add("hidden");
-                        }, 3000);
-                    }
-                });
-            });
-
-            sharedLinkEl.scrollIntoView({ behavior: "smooth" });
-        }
+    if (validateElements(elements)) {
+        setupElementListeners(elements);
     }
 }
 
+function validateElements(elements) {
+    return elements.encryptionType && elements.inputText && elements.form && 
+           elements.removeFileBtn && elements.clearAllBtn && elements.generateBtn && 
+           elements.copyPasswordBtn && elements.toggleSwitch;
+}
 
+function setupElementListeners(elements) {
+    elements.encryptionType.addEventListener("change", toggleEncryptionOptions);
+    elements.inputText.addEventListener("input", handleInputChange);
+    elements.form.addEventListener("submit", handleSubmit);
+    elements.removeFileBtn.addEventListener("click", removeFile);
+    elements.clearAllBtn.addEventListener("click", clearAll);
+    elements.generateBtn.addEventListener("click", generateRandomPassword);
+    elements.copyPasswordBtn.addEventListener("click", () => copyToClipboard("generated-password", "password-copy-feedback"));
+    elements.copyOutputBtn?.addEventListener("click", () => copyToClipboard("output-text", "output-copy-feedback"));
+    elements.toggleSwitch.addEventListener("change", updateToggleLabels);
 
+    // Add file input change listener
+    const fileInput = document.getElementById("file-input");
+    if (fileInput) {
+        fileInput.addEventListener("change", () => {
+            const removeBtn = document.getElementById("remove-file-btn");
+            if (removeBtn) {
+                removeBtn.style.display = fileInput.files.length > 0 ? "inline-block" : "none";
+            }
+        });
+    }
 
+    setupShareLinkListeners(elements);
+}
+
+function setupShareLinkListeners(elements) {
+    if (elements.copyShareBtn && elements.shareLink) {
+        elements.copyShareBtn.addEventListener("click", () => {
+            const linkText = elements.shareLink.textContent.trim();
+            navigator.clipboard.writeText(linkText).then(() => {
+                const feedback = document.getElementById("shared-link-feedback");
+                if (feedback) {
+                    feedback.style.display = "block";
+                    feedback.classList.add("show");
+                    setTimeout(() => {
+                        feedback.classList.remove("show");
+                        setTimeout(() => {
+                            feedback.style.display = "none";
+                        }, 300);
+                    }, 3000);
+                }
+            });
+        });
+    }
+}
+
+// ===== UI State Management =====
 function toggleEncryptionOptions() {
     const type = document.getElementById("encryption-type").value.trim().toLowerCase();
     const passwordInputWrapper = document.getElementById("password-input");
+    const fileSection = document.querySelector("#encoding-section #file-section");
     const isAdvanced = type.includes("advanced");
 
     if (passwordInputWrapper) {
@@ -77,11 +104,18 @@ function toggleEncryptionOptions() {
         }
     }
 
+    if (fileSection) {
+        if (isAdvanced) {
+            fileSection.classList.remove("hidden");
+        } else {
+            fileSection.classList.add("hidden");
+        }
+    }
+
     updateToggleLabels();
     toggleInputMode();
 }
 
-
 function updateToggleLabels() {
     const type = document.getElementById("encryption-type")?.value;
     const leftLabel = document.getElementById("toggle-left-label");
@@ -112,6 +146,7 @@ function toggleInputMode() {
     removeBtn.style.display = fileSelected ? "inline-block" : "none";
 }
 
+// ===== Form Handling =====
 async function handleSubmit(event) {
     event.preventDefault();
 
@@ -133,6 +168,10 @@ async function handleSubmit(event) {
             : decryptFile(fileInput, password);
     }
 
+    await handleTextOperation(encryptionType, operation, password);
+}
+
+async function handleTextOperation(encryptionType, operation, password) {
     const payload = {
         "encryption-type": encryptionType,
         operation: operation,
@@ -153,6 +192,7 @@ async function handleSubmit(event) {
     }
 }
 
+// ===== Utility Functions =====
 function removeFile() {
     const fileInput = document.getElementById("file-input");
     if (fileInput) fileInput.value = "";
@@ -168,19 +208,30 @@ function generateRandomPassword() {
         charset.charAt(Math.floor(Math.random() * charset.length))
     ).join("");
     const passwordField = document.getElementById("generated-password");
-    if (passwordField) passwordField.value = password;
+    if (passwordField) {
+        passwordField.value = password;
+        // Check if we should start Pacman
+        checkForPacman();
+    }
 }
 
 function copyToClipboard(elementId, feedbackId) {
     const el = document.getElementById(elementId);
     const feedback = document.getElementById(feedbackId);
-    if (!el || !feedback) return;
 
-    navigator.clipboard.writeText(el.textContent || el.value || "").then(() => {
-        feedback.classList.add("show");
-        setTimeout(() => {
-            feedback.classList.remove("show");
-        }, 3000);
+    if (!el || !el.value) return;
+
+    navigator.clipboard.writeText(el.value).then(() => {
+        if (feedback) {
+            feedback.style.display = "block";
+            feedback.classList.add("show");
+            setTimeout(() => {
+                feedback.classList.remove("show");
+                setTimeout(() => {
+                    feedback.style.display = "none";
+                }, 300); // Wait for fade-out animation to complete
+            }, 3000);
+        }
     });
 }
 
@@ -196,6 +247,11 @@ function clearAll() {
     document.getElementById("encoding-section")?.style.setProperty("display", "block");
 }
 
+function handleInputChange() {
+    toggleInputMode();
+    checkForPacman();
+}
+
 function checkForPacman() {
     const val = document.getElementById("input-text").value.trim().toLowerCase();
     const pacSection = document.getElementById("pacman-section");
@@ -210,6 +266,7 @@ function checkForPacman() {
     }
 }
 
-
 function startPacman() { }
 function exitGame() { }
+
+