Modules
Termbox2 NIF for Elixir - A terminal UI library.
Stub module for backward compatibility.
This module serves as a documentation reference for the ANSI terminal functionality.
Consolidated ANSI behaviours for terminal functionality. Consolidates: SixelGraphics.Behaviour, TerminalStateBehaviour, TextFormattingBehaviour.
Behaviour for Kitty graphics protocol support.
Behaviour for Sixel graphics support.
Behaviour for managing terminal state saving and restoring.
Defines the behaviour for text formatting in the terminal. This includes handling text attributes, colors, and special text modes.
Provides benchmarking capabilities for the ANSI handling system. Measures performance of parsing and processing ANSI sequences.
Optimized ANSI parser with caching for common sequences.
Consolidated character set management for the terminal emulator. Combines: Handler, StateManager, Translator, and core CharacterSets functionality. Supports G0, G1, G2, G3 character sets and their switching operations.
US ASCII character set identifier.
Translation maps for all supported character sets.
DEC Special Graphics character set identifier.
Handles character set control sequences and state changes.
Manages character set state and operations.
Handles character set translations and mappings. Delegates per-charset data lookups to CharsetData.
UK character set identifier.
Provides character translation tables for different character sets. Maps characters between different character sets according to ANSI standards.
Handles terminal state queries and device status reports. This includes cursor position reports, device status reports, and terminal identification queries.
Handles extended ANSI sequences and provides improved integration with the screen buffer. Functional Programming Version - All try/catch blocks replaced with with statements.
Parses raw ANSI terminal input bytes into Raxol Event structs.
Animation support for the Kitty graphics protocol.
Complete Kitty graphics protocol support for terminal rendering.
Handles the parsing logic for Kitty graphics protocol sequences.
Represents the state during parsing of a Kitty graphics data stream. Tracks control parameters, chunked data, and image buffers.
Provides monitoring capabilities for the ANSI handling system. Tracks performance metrics, errors, and sequence statistics.
Consolidated mouse handling for the terminal emulator. Combines MouseEvents and MouseTracking functionality. Supports various mouse tracking modes and event reporting.
Handles mouse event reporting for the terminal emulator.
Handles mouse tracking and focus tracking for the terminal.
ANSI escape sequence parser for terminal emulation.
Pure Elixir PNG decoder using :zlib.
Consolidated SGR (Select Graphic Rendition) handling for ANSI escape sequences. Combines: SGR formatting, SGRHandler, and SGRProcessor functionality.
SGR parameter formatting for the Raxol Terminal ANSI TextFormatting module. Handles SGR parameter parsing, formatting, and attribute handling.
Handles parsing of SGR (Select Graphic Rendition) ANSI escape sequences. Translates SGR codes into updates on a TextFormatting style map.
Optimized SGR (Select Graphic Rendition) processor for ANSI escape sequences. Uses compile-time optimizations and pattern matching for maximum performance.
Processes SGR (Select Graphic Rendition) ANSI escape sequences.
Handles parsing and processing of ANSI escape sequences. This module extracts the ANSI sequence parsing logic from the main emulator.
ANSI Color Sequence Handler.
ANSI Cursor Sequence Handler.
ANSI Terminal Modes Sequence Handler.
Dithering algorithms for Sixel image color quantization.
Complete Sixel graphics support for terminal rendering.
Handles Sixel color palette management.
Handles the parsing logic for Sixel graphics data streams within a DCS sequence.
Represents the state during the parsing of a Sixel graphics data stream. Tracks position, color, palette, and pixel buffer information.
Handles rendering Sixel graphics data from a pixel buffer.
A state machine for parsing ANSI escape sequences. This module provides a more efficient alternative to regex-based parsing.
Manages terminal state operations for ANSI escape sequences.
Consolidated text formatting module for the terminal emulator. Combines Core, Attributes, and Colors functionality. Handles advanced text formatting features including double-width/height, text attributes, and color management.
Text attribute handling for ANSI text formatting.
Color handling utilities for ANSI text formatting.
Core text formatting functionality.
SGR parameter formatting and parsing for text styles.
Consolidated ANSI utilities for terminal functionality. Combines: SixelPatternMap, AnsiProcessor, SequenceParser, AnsiParser, and Emitter.
Provides comprehensive parsing for ANSI escape sequences. Determines the type of sequence and extracts its parameters.
Processes ANSI escape sequences for terminal control.
ANSI escape sequence generation module.
Helper module for parsing ANSI escape sequences.
Provides a mapping from Sixel characters to their 6-bit pixel patterns.
Consolidated window handling for the terminal emulator. Combines WindowEvents and WindowManipulation functionality. Supports window events, resizing, positioning, and state management.
Handles window events for terminal control.
Handles window manipulation sequences for terminal control.
Implements advanced terminal features for modern terminal emulators.
Manages the terminal buffer state and operations.
Buffer manager for terminal operations.
Buffer server stub for test compatibility.
Manages terminal cell operations and attributes.
Manages terminal character editing operations.
Manages character set state and operations for the screen buffer. This module handles character set designations, G-sets, and single shifts.
A thread-safe buffer implementation using GenServer for concurrent access. Provides synchronous operations to ensure data integrity when multiple processes are reading/writing to the buffer simultaneously.
Compatibility adapter for buffer content operations. Forwards calls to Raxol.Terminal.ScreenBuffer.Operations.
Manages cursor state and operations for the screen buffer. This module handles cursor position, visibility, style, and blink state.
Tracks damage regions in a terminal buffer for efficient rendering. Damage regions indicate areas that have changed and need to be redrawn.
Compatibility adapter for buffer erasing operations. Forwards calls to Raxol.Terminal.ScreenBuffer.Operations.
Manages text formatting state and operations for the screen buffer. This module handles text attributes, colors, and style management.
Provides functionality for line editing operations in the terminal buffer.
Provides line-level operations for the screen buffer. This module handles operations like inserting, deleting, and manipulating lines.
Character-level operations for buffer lines. Handles character insertion, deletion, and manipulation within lines.
Line deletion operations for terminal buffers. Handles deletion of single and multiple lines, with support for scroll regions.
Line insertion operations for terminal buffers. Handles insertion of single and multiple lines with style support.
Line management operations for terminal buffers. Handles line creation, retrieval, and manipulation.
Shared utility functions for line operations. Extracted to eliminate code duplication between Deletion and Insertion modules.
Compatibility adapter for consolidated buffer operations. Forwards calls to Raxol.Terminal.ScreenBuffer.Operations.
Handles text pasting operations for terminal buffers.
Handles buffer state querying operations. This module provides functions for querying the state of the screen buffer, including dimensions, content, and selection state.
Safe buffer manager that handles buffer operations with error recovery.
Terminal scroll buffer module.
Handles scroll region operations for the screen buffer. This module manages the scroll region boundaries and provides functions for scrolling content within the defined region.
Handles scrollback buffer operations for the screen buffer. This module manages the history of lines that have scrolled off the screen, including adding, retrieving, and clearing scrollback content.
Handles scrolling operations for the terminal buffer.
Manages text selection operations for the terminal. This module handles all selection-related operations including
Manages terminal text formatting operations.
Handles writing characters and strings to the Raxol.Terminal.ScreenBuffer. Responsible for character width, bidirectional text segmentation, and cell creation.
Helper functions for cache eviction strategies. Provides shared implementations for LRU, LFU, and FIFO eviction policies.
Unified caching system for the Raxol terminal emulator. This module provides a centralized caching mechanism that consolidates all caching operations across the terminal system, including
Manages terminal capabilities including detection, negotiation, and caching.
Defines types and structures for terminal capabilities management.
Terminal character cell module.
Cached version of Cell operations for performance optimization.
Handles wide character and bidirectional text support for the terminal emulator.
Manages character sets for the terminal emulator.
Manages terminal character sets and encoding operations.
Provides character mapping functions for different character sets.
Provides operations for managing character sets and their state.
Defines types used across the charset modules.
Manages the terminal character sets.
Provides a high-level interface for clipboard operations.
Handles clipboard content formatting and filtering.
Manages clipboard history for the terminal.
Manages clipboard operations for the terminal, including copying and pasting text.
Manages clipboard content storage and retrieval.
Handles clipboard synchronization between different terminal instances.
Defines the behaviour for clipboard operations in the terminal.
Manages terminal colors and color operations.
True color (24-bit RGB) support for Raxol terminal applications.
Low-level ANSI color code helpers: 256-color and 16-color mapping, hex string parsing, and hex formatting.
Color space math for TrueColor: RGB/HSL/HSV/XYZ/Lab conversions and luminance calculations.
Terminal color capability detection via environment variables.
Named color constants and lookup for TrueColor.
Manages terminal colors and color-related operations.
Handlers for CSI (Control Sequence Introducer) commands. This is a simplified version that delegates to the available handler modules.
Handles cursor-related CSI sequences.
Handles cursor movement operations for CSI sequences.
Handles CSI mode commands (Set Mode/Reset Mode).
Handles screen-related CSI sequences.
Screen handling utilities for CSI commands.
Defines the structure for terminal commands.
Unified command handler that consolidates all terminal command processing.
Handles parsing of command parameters in terminal sequences.
Handles cursor movement related CSI commands.
Shared utility functions for cursor handling commands. Eliminates code duplication between CursorHandler and CSIHandler.
Handles device-specific terminal commands like Device Attributes (DA) and Device Status Report (DSR). This module provides direct implementations.
Handles editor-related terminal commands.
Handles terminal erase commands like Erase in Display (ED) and Erase in Line (EL). This module provides simple fallback implementations.
Manages terminal command processing and execution. This module is responsible for handling command parsing, validation, and execution.
Consolidated OSC (Operating System Command) handler for terminal control sequences. Combines all OSC handler functionality including window, clipboard, color, and selection operations.
Handles clipboard-related OSC commands.
Handles color-related OSC commands.
Handles color palette OSC commands.
Parses color specifications from OSC commands.
Parses font specifications from OSC commands.
Parses hyperlink specifications from OSC 8 commands.
Handles selection-related OSC commands.
Parses selection specifications from OSC commands.
Handles window-related OSC commands.
Handles command processing for the terminal emulator. This module is responsible for parsing, validating, and executing terminal commands.
Handles screen manipulation commands in the terminal.
Handles scrolling operations for the terminal screen buffer.
Handles window-related commands and operations for the terminal.
Handles terminal settings and behavior, including
Manages caching for terminal animations using the unified caching system.
Terminal configuration application.
Terminal capability detection and management.
Validates terminal configuration settings.
Default terminal configuration values.
Defines the behaviour for terminal environment configuration.
Manages terminal configuration including settings, preferences, and environment variables. This module is responsible for handling configuration operations and state.
Handles persistence and migration of terminal configurations.
Terminal configuration profile management.
Schema definitions for terminal configuration.
Utility functions for handling terminal configuration maps.
Validation logic for terminal configuration.
Handles C0 control codes and simple ESC sequences.
Provides cursor manipulation functions for the terminal emulator. This module handles operations like moving the cursor, setting its visibility, and managing cursor state.
Handles GenServer callbacks for the cursor manager. Extracted from Raxol.Terminal.Cursor.Manager to reduce file size.
Handles cursor state management operations for the terminal cursor. Extracted from Raxol.Terminal.Cursor.Manager to reduce file size.
Manages cursor state and operations in the terminal. Handles cursor position, visibility, style, and blinking state.
Handles cursor movement operations for the terminal cursor. Extracted from Raxol.Terminal.Cursor.Manager to reduce file size.
Handles cursor style and visibility control for the terminal emulator.
Handles device status reporting and attributes for the terminal emulator.
ASCII art rendering system for the Raxol terminal emulator.
Handles raw terminal input/output and event generation.
Behaviour specification for terminal drivers.
Event dispatching helpers for Driver: sends events to the dispatcher and handles initial resize notification.
Translates termbox NIF events into Raxol.Core.Events.Event structs.
Input buffer management for Driver: accumulates bytes, detects incomplete escape sequences, and flushes complete sequences for parsing.
Termbox NIF initialization, shutdown, and recovery helpers.
Terminal size detection: termbox, stty, and fallback strategies.
Enterprise-grade terminal emulator with VT100/ANSI support and high-performance parsing.
Handles ANSI sequence processing for the terminal emulator.
Adapter module to make EmulatorLite compatible with existing code that expects the full Emulator struct.
Provides buffer management functionality for the terminal emulator.
Buffer operation functions extracted from the main emulator module. Handles active buffer management and buffer switching operations.
Handles CSI/ESC/SGR/OSC and related command logic for the terminal emulator. Extracted from the main emulator module for clarity and maintainability.
Handles emulator constructor functions. This module extracts the constructor logic from the main emulator.
Coordinates complex operations that require interaction between multiple terminal subsystems. This module handles the orchestration logic that was previously embedded in the main Emulator module.
Handles core emulator functionality including input processing and scrolling.
Cursor operation functions extracted from the main emulator module. Handles cursor movement, positioning, and blink operations.
Dimension and resize operation functions extracted from the main emulator module. Handles terminal resizing and dimension getters.
GenServer implementation for the Terminal Emulator.
Handles state management for the terminal emulator. Provides functions for managing terminal state, modes, and character sets.
Emulator construction helpers: creates full (GenServer) and basic (struct-only) emulators.
Utility and helper functions for the terminal emulator. Extracted from the main emulator module for clarity and reuse.
Handles input processing for the terminal emulator. Provides functions for key event handling, command history, and input parsing.
Mode operation functions extracted from the main emulator module. Handles terminal mode setting and resetting operations.
Optimized input processing for the terminal emulator.
Handles output processing for the terminal emulator. Provides functions for output buffering, processing, and formatting.
Handles emulator reset and cleanup functions. This module extracts the reset logic from the main emulator.
Enhanced terminal emulator with comprehensive error handling. Refactored to use functional error handling patterns instead of try/catch.
Screen operation functions extracted from the main emulator module. Handles screen clearing and line clearing operations.
Scroll operation functions extracted from the main emulator module. Handles scroll region management and scroll positioning.
Provides terminal emulator structure and related functionality.
Handles text styling and formatting for the terminal emulator. Provides functions for managing character attributes, colors, and text formatting.
Defines the behaviour for terminal emulator style management. This includes handling text attributes, colors, and text formatting.
Telemetry instrumentation for the terminal emulator.
Text operation functions extracted from the main emulator module. Handles text writing with charset translation and cursor updates.
Defines the behaviour for the core Terminal Emulator.
Factory module for creating terminal emulator instances. This module is responsible for initializing and configuring new emulator instances.
Lightweight terminal emulator for performance-critical paths.
Base parser utilities for escape sequence parsers.
Parser for CSI (Control Sequence Introducer) escape sequences.
Cached version of CSI parser for performance optimization.
Parser for SCS (Select Character Set) escape sequences.
Handles parsing of ANSI escape sequences and other control sequences.
Defines the structure for terminal events.
Handles terminal events including input events, state changes, and notifications. This module is responsible for processing and dispatching events to appropriate handlers.
Handles various terminal events including mouse, keyboard, and focus events. This module is responsible for processing and responding to user interactions.
Optimized event processing pipeline for terminal events.
Global event management for terminal interactions.
Handles terminal events and dispatches them to appropriate handlers.
Manages terminal extensions, including loading, unloading, and executing extension commands.
Unified extension management GenServer that provides a single interface for loading, unloading, and managing terminal extensions.
Manages font operations and settings for the terminal, including font family, size, weight, and style.
Unified terminal text formatting and styling operations.
Manages terminal command history buffer operations. This module handles the storage and retrieval of command history.
Manages terminal command history operations including history storage, retrieval, and navigation. This module is responsible for handling all history-related operations in the terminal.
Unified input/output system for the terminal emulator.
Pure Elixir terminal I/O using OTP 28+ raw mode and IO.ANSI.
Unified facade for terminal inline image display.
ETS-backed cache for decoded and encoded terminal images.
Handles input processing for the terminal.
Manages input buffering for the terminal emulator.
Handles character processing, translation, and writing to the terminal buffer.
Handles clipboard operations for the terminal emulator.
Handles various control sequences for the terminal emulator. Includes CSI, OSC, DCS, PM, and APC sequence handling.
Core input handling functionality for the terminal emulator. Manages the main input buffer and cursor state.
Defines the base event struct and common types for input events.
Represents a keyboard input event.
Represents a mouse input event.
Handles file drag-and-drop operations for the terminal emulator.
A simple data structure for managing input buffer state.
Utility functions for Raxol.Terminal.Input.InputBuffer.
Handles input processing for the terminal emulator.
Processes input events for the terminal emulator.
Manages terminal input processing including character input, key events, and input mode handling. This module is responsible for processing all input events and converting them into appropriate terminal actions.
Comprehensive mouse event handling for terminal applications.
Handles special key combinations and their escape sequences.
Handles text input processing for the terminal emulator. This module extracts the text input handling logic from the main emulator.
Defines shared types for the Raxol terminal input subsystem.
Main input handler module that coordinates between different input handling components.
Coordinates terminal integration components and provides a unified interface for terminal operations.
Handles buffer and cursor management for the terminal.
Renders a list of cells to the terminal.
Manages configuration for the terminal integration.
Main integration module that provides a GenServer-based interface for terminal integration.
Handles terminal output rendering and display management using Termbox2.
Manages the state of the integrated terminal system.
Manages memory usage and limits for the terminal emulator.
ETS-backed metrics collection and export module.
Handles terminal mode management functions. This module extracts the mode handling logic from the main emulator.
Manages terminal modes (DEC Private Modes, Standard Modes) and their effects.
Handles saved state operations for the mode manager. This includes saving and restoring cursor positions, screen states, and other terminal modes.
Manages terminal mode state and transitions.
Handles terminal modes and state transitions for the terminal emulator.
Handles DEC Private mode operations and their side effects. Manages the implementation of DEC private mode changes and their effects on the terminal.
Handles mouse mode operations and their side effects. Manages different mouse reporting modes and their effects on the terminal.
Handles screen buffer mode operations and their side effects. Manages alternate screen buffer switching and related functionality.
Handles standard mode operations and their side effects. Manages standard terminal modes like insert mode and line feed mode.
Defines types and constants for terminal modes. Provides a centralized registry of all terminal modes and their properties.
Manages mouse events and tracking in the terminal, including button clicks, movement, and wheel events.
Provides unified mouse handling functionality for the terminal emulator. This module handles mouse events, tracking, and state management.
Implements cursor-related operations for the terminal emulator.
Implements screen-related operations for the terminal emulator.
Implements scroll-related operations for the terminal emulator.
Implements selection-related operations for the terminal emulator.
Implements state-related operations for the terminal emulator.
Implements text-related operations for the terminal emulator.
Defines the behaviour for core terminal operations.
Manages terminal output buffering, event processing, styling, and formatting. This module handles output events, applies styles and formatting rules, and tracks metrics.
Processes output events for the terminal emulator.
Simple output buffer implementation for terminal output.
Manages terminal output operations including writing, flushing, and output buffering. This module is responsible for handling all output-related operations in the terminal.
Parser state for the terminal emulator.
Manages the state of the terminal parser, including escape sequences, control sequences, and parser modes.
Refactored version of Terminal Parser State Manager using pattern matching instead of cond statements.
Defines the behaviour for parser states.
Behaviour for terminal parser state management.
Handles the CSI Entry state in the terminal parser. This state is entered after receiving an ESC [ sequence.
Handles the :csi_intermediate state of the terminal parser.
Handles the :csi_param state of the terminal parser.
Handles the :dcs_entry state of the terminal parser.
Handles the :dcs_passthrough_maybe_st state of the terminal parser.
Handles the :dcs_passthrough state of the terminal parser.
Handles the :designate_charset state of the terminal parser.
Handles the :escape state of the terminal parser.
Handles parsing in the ground state, the default state of the terminal.
Handles the :osc_string_maybe_st state of the terminal parser.
Handles the OSC String state in the terminal parser. This state is entered when an OSC sequence is initiated.
Alias module for parser state functionality. This module delegates to the actual implementation in Parser.ParserState.
Consolidated terminal parser state manager combining simple emulator operations with comprehensive parser state management.
Handles plugin dependency resolution for the terminal emulator. This module extracts the plugin dependency resolution logic from the main emulator.
Manages terminal plugins with advanced features
Unified plugin system for the Raxol terminal emulator. Handles themes, scripting, and extensions.
Registry for terminal processes and components.
Terminal renderer module.
Behaviour definition for terminal rendering backends.
GPU-accelerated rendering backend for Raxol terminals using Metal (macOS) and Vulkan.
GPU-accelerated terminal renderer.
Programming font ligature rendering system for Raxol terminals.
Optimized terminal renderer with efficient style handling.
Provides a unified interface for terminal rendering operations.
Provides screen manipulation functions for the terminal emulator.
Manages the terminal's screen buffer state (grid, scrollback, selection). This module serves as the main interface for terminal buffer operations, delegating specific operations to specialized modules in Raxol.Terminal.Buffer.*.
Manages buffer attributes including formatting, charset, and cursor state. Consolidates: Formatting, TextFormatting, Charset, Cursor functionality.
Implements behaviour callbacks for the terminal screen buffer.
Handles character set operations for the screen buffer.
Core functionality for screen buffer creation, initialization, and basic queries. Consolidates: Initializer, Common, Helpers, and basic state management.
Data structure adapter for ScreenBuffer operations.
Handles all erase operations for the terminal screen buffer.
Manages buffer lifecycle, memory tracking, damage regions, and buffer switching. Consolidates: Manager, UnifiedManager, SafeManager, EnhancedManager, DamageTracker.
Handles memory usage calculations for the terminal screen buffer.
All buffer mutation operations. Consolidates: Operations, Ops, OperationsCached, Writer, Updater, CharEditor, LineOperations, Eraser, Content, Paste functionality.
Erasing operations for the screen buffer.
Handles region operations for the terminal screen buffer.
Handles screen buffer operations for the terminal emulator. This module provides functions for managing the screen state, including clearing, erasing, and marking damaged regions.
Scroll operations for ScreenBuffer: region management and scroll up/down.
Manages scroll region boundaries for the screen buffer.
Text selection operations for the screen buffer. Handles selection creation, updates, text extraction, and clipboard operations.
Shared operations for screen buffer modules to eliminate code duplication. This module contains common functionality used across different screen buffer implementations.
Backward-compatible adapter that maps the old ScreenBuffer API to the new consolidated modules. This allows existing code to work without changes while we migrate to the consolidated architecture.
Defines the behaviour for screen buffer operations in the terminal. This module specifies the callbacks that must be implemented by any module that wants to act as a screen buffer.
Manages screen buffer operations for the terminal emulator. This module handles operations related to the main and alternate screen buffers, including buffer switching, initialization, and state management.
Handles screen update operations for the terminal.
Unified scripting system for the Raxol terminal emulator. Handles script execution, management, and integration with the terminal.
Manages terminal scrolling operations with advanced features.
Handles scroll optimization for better performance. Dynamically adjusts batch size based on recent scroll patterns and (optionally) performance metrics.
Shared utilities for analyzing scroll patterns.
Handles predictive scrolling operations for the terminal. Tracks recent scrolls and provides pattern analysis for smarter prediction.
Unified scroll management system for the terminal.
Handles scroll synchronization across terminal splits. Tracks recent sync events for analytics and smarter sync strategies.
Manages terminal scrollback buffer operations.
Manages search state, options, matches, and history for terminal search operations.
Manages terminal search operations including text search, pattern matching, and search history. This module is responsible for handling all search-related operations in the terminal.
Manages text selection operations in the terminal.
Terminal session module.
Handles serialization and deserialization of terminal session state.
Handles persistence of terminal sessions.
Terminal multiplexing system providing tmux-like session management for Raxol.
Session cleanup: expired session removal and resource monitoring.
Client connection to a session.
Helper functions for SessionManager operations.
Terminal pane within a window.
Session persistence: save/restore sessions to/from disk.
Terminal session structure.
State query helpers for SessionManager: finding panes/windows and building summaries.
Terminal window within a session.
Window and pane creation helpers for SessionManager.
Manages terminal split windows and panes.
Provides state management for the terminal emulator. This module handles operations like creating new states, saving and restoring states, and managing state transitions.
State manager for terminal emulator state. Provides functions for managing modes, attributes, and state stack.
Manages terminal state transitions and state stack operations. This module is responsible for maintaining and manipulating the terminal's state.
Manages text styling and formatting for the terminal emulator. This module provides a clean interface for managing text styles, colors, and attributes.
Handles style management for the terminal emulator. This module extracts the style handling logic from the main emulator.
Manages terminal style state and operations. This module handles text attributes, colors, and formatting for terminal output.
Manages terminal style operations including colors, attributes, and formatting. This module is responsible for handling all style-related operations in the terminal.
Supervisor for terminal-related processes.
Defines the structure for synchronized components.
Manages synchronization between different terminal components (splits, windows, tabs). Provides a high-level interface for component synchronization and state management.
Defines the synchronization protocol for terminal components. Handles message formats, versioning, and conflict resolution strategies.
Unified synchronization system for the Raxol terminal emulator. This module provides centralized synchronization mechanisms for
Unified synchronization system for the terminal emulator. Handles synchronization between splits, windows, and tabs with different consistency levels.
Manages terminal tabs and their associated sessions. This module handles
Provides unified tab management functionality for the terminal emulator. This module handles tab creation, switching, state management, and configuration.
Integration module for managing tabs and their associated windows.
Logs all Raxol.Terminal telemetry events for observability and debugging.
Parses raw byte streams into terminal events and commands. Handles escape sequences (CSI, OSC, DCS, etc.) and plain text.
Utility functions for terminal operations, providing cross-platform and consistent handling of terminal capabilities and dimensions.
Alias module for Raxol.Terminal.ANSI.TextFormatting. This module re-exports the functionality from ANSI.TextFormatting to maintain compatibility.
Manages terminal themes with advanced features
Unified theme system for the Raxol terminal emulator. Handles theme management, preview, switching, and customization.
Tooltip display functionality for terminal UI.
Unicode handling utilities for terminal rendering.
Stub module for terminal input validation.
Represents a terminal window with its properties and state.
Refactored Window.Manager that delegates to GenServer implementation.
Pure-functional helpers for spatial navigation and position registration within the WindowManagerServer state.
Operations module for window management functionality. Handles all the complex logic for window creation, updates, and hierarchy management.
Pure functional state operations for the WindowManagerServer.
GenServer implementation for terminal window management in Raxol.
Registry for managing multiple terminal windows.
A unified window manager for terminal applications.
Terminal emulation and rendering for Elixir.