cliedit 0.3.0 → 0.4.0

package/README.md

@@ -14,16 +14,20 @@ It includes line wrapping, visual navigation, smart auto-indentation, undo/redo,
 - **Undo/Redo:** `Ctrl+Z` / `Ctrl+Y` for persistent history.
 - **Text Selection:** `Ctrl+Arrow` keys to select text.
 - **Clipboard Support:** `Ctrl+C` (Copy), `Ctrl+X` (Cut), `Ctrl+V` (Paste) for system clipboard (macOS, Windows, **and Linux** via `xclip`).
+- **Syntax Highlighting:** Lightweight highlighting for Brackets `()` `[]` `{}` and Strings `""` `''`.
 - **File I/O:** Loads from and saves to the filesystem.
 - **Search & Replace:** `Ctrl+W` to find text, `Ctrl+R` to find and replace interactively.
 - **Go to Line:** `Ctrl+L` to quickly jump to a specific line number.
 - **Smart Auto-Indentation:** Automatically preserves indentation level when pressing Enter.
+- **Block Indentation:** Use `Tab` / `Shift+Tab` to indent or outdent selected blocks of text.
 - **Smart Navigation:** `Alt + Left/Right` to jump by words, `Ctrl + M` to jump between matching brackets.
+- **Line Moving:** `Alt + Up/Down` to move the current line or selection up and down.
+- **Line Duplication:** `Ctrl+D` to duplicate the current line or selection.
 - **Piping Support:** Works with standard Unix pipes (e.g. `cat file.txt | cliedit`).
 - **Crash Recovery:** Automatically saves changes to a hidden swap file (e.g. `.filename.swp`) to prevent data loss.
 
 ## Installation
-```bash
+```shell
 npm install cliedit
 ````
 
@@ -31,7 +35,7 @@ npm install cliedit
 
 The package exports an `async` function `openEditor` that returns a `Promise`. The promise resolves when the user quits the editor.
 
-```javascript
+```typescript
 import { openEditor } from 'cliedit';
 import path from 'path';
 
@@ -64,7 +68,7 @@ getCommitMessage();
 
 `cliedit` supports standard input piping. When used in a pipeline, it reads the input content, then re-opens the TTY to allow interactive editing.
 
-```bash
+```shell
 # Edit a file using cat
 cat README.md | node my-app.js
 
@@ -101,7 +105,7 @@ If the process crashes or is terminated abruptly, the next time you open the fil
 
 The main editor class. You can import this directly if you need to extend or instantiate the editor with custom logic.
 
-```javascript
+```typescript
 import { CliEditor } from 'cliedit';
 ```
 
@@ -109,7 +113,7 @@ import { CliEditor } from 'cliedit';
 
 Key types are also exported for convenience:
 
-```javascript
+```typescript
 import type {
   DocumentState,
   VisualRow,

package/dist/constants.d.ts

@@ -11,6 +11,9 @@ export declare const ANSI: {
     RESET_COLORS: string;
     ENTER_ALTERNATE_SCREEN: string;
     EXIT_ALTERNATE_SCREEN: string;
+    YELLOW: string;
+    CYAN: string;
+    GREEN: string;
 };
 /**
  * Key definitions for special keypresses (using Ctrl+ keys for reliable detection).
@@ -47,4 +50,8 @@ export declare const KEYS: {
     PAGE_UP: string;
     PAGE_DOWN: string;
     TAB: string;
+    SHIFT_TAB: string;
+    ALT_UP: string;
+    ALT_DOWN: string;
+    CTRL_D: string;
 };

package/dist/constants.js

@@ -12,6 +12,10 @@ export const ANSI = {
     RESET_COLORS: '\x1b[0m', // Reset colors
     ENTER_ALTERNATE_SCREEN: '\x1b[?1049h', // Enter alternate screen
     EXIT_ALTERNATE_SCREEN: '\x1b[?1049l', // Exit alternate screen
+    // Syntax Highlighting Colors
+    YELLOW: '\x1b[33m',
+    CYAN: '\x1b[36m',
+    GREEN: '\x1b[32m',
 };
 /**
  * Key definitions for special keypresses (using Ctrl+ keys for reliable detection).
@@ -52,4 +56,8 @@ export const KEYS = {
     PAGE_UP: 'pageup',
     PAGE_DOWN: 'pagedown',
     TAB: '\t',
+    SHIFT_TAB: 'SHIFT_TAB', // Internal representation
+    ALT_UP: 'ALT_UP', // Internal representation
+    ALT_DOWN: 'ALT_DOWN', // Internal representation
+    CTRL_D: '\x04',
 };

package/dist/editor.d.ts

@@ -10,6 +10,7 @@ import { historyMethods } from './editor.history.js';
 import { ioMethods } from './editor.io.js';
 import { TKeyHandlingMethods } from './editor.keys.js';
 import { TSelectionMethods } from './editor.selection.js';
+import { syntaxMethods } from './editor.syntax.js';
 type TEditingMethods = typeof editingMethods;
 type TClipboardMethods = typeof clipboardMethods;
 type TNavigationMethods = typeof navigationMethods;
@@ -17,7 +18,8 @@ type TRenderingMethods = typeof renderingMethods;
 type TSearchMethods = typeof searchMethods;
 type THistoryMethods = typeof historyMethods;
 type TIOMethods = typeof ioMethods;
-export interface CliEditor extends TEditingMethods, TClipboardMethods, TNavigationMethods, TRenderingMethods, TSearchMethods, THistoryMethods, TIOMethods, TKeyHandlingMethods, TSelectionMethods {
+type TSyntaxMethods = typeof syntaxMethods;
+export interface CliEditor extends TEditingMethods, TClipboardMethods, TNavigationMethods, TRenderingMethods, TSearchMethods, THistoryMethods, TIOMethods, TKeyHandlingMethods, TSelectionMethods, TSyntaxMethods {
 }
 /**
  * Main editor class managing application state, TTY interaction, and rendering.
@@ -57,6 +59,7 @@ export declare class CliEditor {
         end: number;
     }>>;
     searchResultIndex: number;
+    syntaxCache: Map<number, Map<number, string>>;
     history: HistoryManager;
     swapManager: SwapManager;
     isCleanedUp: boolean;

package/dist/editor.editing.d.ts

@@ -37,6 +37,23 @@ declare function deleteForward(this: CliEditor): void;
  * @param closeChar The corresponding closing character (e.g., ')', ']', '}').
  */
 declare function handleAutoPair(this: CliEditor, openChar: string, closeChar: string): void;
+/**
+ * Indents the selected lines (Block Indentation).
+ */
+declare function indentSelection(this: CliEditor): void;
+/**
+ * Outdents the selected lines (Block Outdent).
+ */
+declare function outdentSelection(this: CliEditor): void;
+/**
+ * Moves the current line or selection up or down.
+ * @param direction -1 for Up, 1 for Down
+ */
+declare function moveLines(this: CliEditor, direction: -1 | 1): void;
+/**
+ * Duplicates the current line or selection.
+ */
+declare function duplicateLineOrSelection(this: CliEditor): void;
 export declare const editingMethods: {
     insertContentAtCursor: typeof insertContentAtCursor;
     insertCharacter: typeof insertCharacter;
@@ -45,5 +62,9 @@ export declare const editingMethods: {
     deleteBackward: typeof deleteBackward;
     deleteForward: typeof deleteForward;
     handleAutoPair: typeof handleAutoPair;
+    indentSelection: typeof indentSelection;
+    outdentSelection: typeof outdentSelection;
+    moveLines: typeof moveLines;
+    duplicateLineOrSelection: typeof duplicateLineOrSelection;
 };
 export {};

package/dist/editor.editing.js

@@ -33,6 +33,7 @@ function insertContentAtCursor(contentLines) {
         this.cursorX = lastPasteLine.length;
     }
     this.setDirty();
+    this.invalidateSyntaxCache();
     this.recalculateVisualRows();
 }
 /**
@@ -42,6 +43,7 @@ function insertCharacter(char) {
     const line = this.lines[this.cursorY] || '';
     this.lines[this.cursorY] = line.slice(0, this.cursorX) + char + line.slice(this.cursorX);
     this.cursorX += char.length;
+    this.invalidateSyntaxCache();
 }
 /**
  * Inserts a soft tab (using configured tabSize).
@@ -49,6 +51,7 @@ function insertCharacter(char) {
 function insertSoftTab() {
     const spaces = ' '.repeat(this.tabSize || 4);
     this.insertCharacter(spaces);
+    // invalidation handled in insertCharacter
 }
 /**
  * Inserts a new line, splitting the current line at the cursor position.
@@ -66,6 +69,7 @@ function insertNewLine() {
     this.cursorY++;
     this.cursorX = indent.length; // Move cursor to end of indent
     this.setDirty();
+    this.invalidateSyntaxCache();
 }
 /**
  * Deletes the character before the cursor, or joins the current line with the previous one.
@@ -90,6 +94,7 @@ function deleteBackward() {
         this.cursorX = 0;
     }
     this.setDirty();
+    this.invalidateSyntaxCache();
 }
 /**
  * Deletes the character after the cursor, or joins the current line with the next one.
@@ -110,6 +115,7 @@ function deleteForward() {
         this.cursorX = 0;
     }
     this.setDirty();
+    this.invalidateSyntaxCache();
 }
 /**
  * Handles auto-pairing of brackets and quotes.
@@ -141,6 +147,129 @@ function handleAutoPair(openChar, closeChar) {
     }
     this.setDirty();
 }
+/**
+ * Indents the selected lines (Block Indentation).
+ */
+function indentSelection() {
+    this.saveState(); // Save state before modification for Undo
+    const selection = this.getNormalizedSelection();
+    if (!selection)
+        return;
+    for (let i = selection.start.y; i <= selection.end.y; i++) {
+        const line = this.lines[i];
+        this.lines[i] = ' '.repeat(this.tabSize) + line;
+    }
+    // Adjust selection anchors
+    if (this.selectionAnchor) {
+        this.selectionAnchor.x += this.tabSize;
+        this.cursorX += this.tabSize;
+    }
+    this.setDirty();
+    this.invalidateSyntaxCache();
+    this.recalculateVisualRows();
+}
+/**
+ * Outdents the selected lines (Block Outdent).
+ */
+function outdentSelection() {
+    this.saveState(); // Save state before modification for Undo
+    // If no selection, try to outdent current line
+    let startY = this.cursorY;
+    let endY = this.cursorY;
+    if (this.selectionAnchor) {
+        const selection = this.getNormalizedSelection();
+        if (selection) {
+            startY = selection.start.y;
+            endY = selection.end.y;
+        }
+    }
+    let changed = false;
+    for (let i = startY; i <= endY; i++) {
+        const line = this.lines[i];
+        // Remove up to tabSize spaces
+        const match = line.match(/^(\s+)/);
+        if (match) {
+            const spaces = match[1].length;
+            const toRemove = Math.min(spaces, this.tabSize);
+            this.lines[i] = line.slice(toRemove);
+            changed = true;
+        }
+    }
+    if (changed) {
+        if (this.selectionAnchor) {
+            // Approximation: shift anchor and cursor left
+            this.selectionAnchor.x = Math.max(0, this.selectionAnchor.x - this.tabSize);
+            this.cursorX = Math.max(0, this.cursorX - this.tabSize);
+        }
+        else {
+            this.cursorX = Math.max(0, this.cursorX - this.tabSize);
+        }
+        this.setDirty();
+        this.invalidateSyntaxCache();
+        this.recalculateVisualRows();
+    }
+}
+/**
+ * Moves the current line or selection up or down.
+ * @param direction -1 for Up, 1 for Down
+ */
+function moveLines(direction) {
+    this.saveState(); // Save state before modification for Undo
+    let startY = this.cursorY;
+    let endY = this.cursorY;
+    if (this.selectionAnchor) {
+        const selection = this.getNormalizedSelection();
+        if (selection) {
+            startY = selection.start.y;
+            endY = selection.end.y;
+        }
+    }
+    // Boundary checks
+    if (direction === -1 && startY === 0)
+        return; // Top
+    if (direction === 1 && endY >= this.lines.length - 1)
+        return; // Bottom
+    // Extract lines to move
+    const count = endY - startY + 1;
+    const linesToMove = this.lines.splice(startY, count);
+    // Insert at new position
+    const newStart = startY + direction;
+    this.lines.splice(newStart, 0, ...linesToMove);
+    // Update selection/cursor
+    this.cursorY += direction;
+    if (this.selectionAnchor) {
+        this.selectionAnchor.y += direction;
+    }
+    this.setDirty();
+    this.recalculateVisualRows();
+}
+/**
+ * Duplicates the current line or selection.
+ */
+function duplicateLineOrSelection() {
+    this.saveState(); // Save state before modification for Undo
+    if (this.selectionAnchor) {
+        const selection = this.getNormalizedSelection();
+        if (!selection)
+            return;
+        const text = this.getSelectedText();
+        // We need to move cursor to end of selection.
+        // Normalized selection end:
+        this.cursorX = selection.end.x;
+        this.cursorY = selection.end.y;
+        const contentLines = text.split('\n');
+        this.insertContentAtCursor(contentLines);
+    }
+    else {
+        // Single line duplication
+        const line = this.lines[this.cursorY];
+        this.lines.splice(this.cursorY + 1, 0, line);
+        this.cursorY++; // Move down to the new line
+        // CursorX stays same? Usually yes.
+    }
+    this.setDirty();
+    this.recalculateVisualRows();
+}
 export const editingMethods = {
     insertContentAtCursor,
     insertCharacter,
@@ -149,4 +278,8 @@ export const editingMethods = {
     deleteBackward,
     deleteForward,
     handleAutoPair,
+    indentSelection,
+    outdentSelection,
+    moveLines,
+    duplicateLineOrSelection,
 };

package/dist/editor.history.js

@@ -38,6 +38,7 @@ function undo() {
     if (state) {
         this.loadState(state);
         this.setDirty();
+        this.invalidateSyntaxCache();
         this.setStatusMessage('Undo successful');
     }
     else {
@@ -52,6 +53,7 @@ function redo() {
     if (state) {
         this.loadState(state);
         this.setDirty();
+        this.invalidateSyntaxCache();
         this.setStatusMessage('Redo successful');
     }
     else {

package/dist/editor.js

@@ -14,6 +14,7 @@ import { historyMethods } from './editor.history.js';
 import { ioMethods } from './editor.io.js';
 import { keyHandlingMethods } from './editor.keys.js';
 import { selectionMethods } from './editor.selection.js';
+import { syntaxMethods } from './editor.syntax.js';
 const DEFAULT_STATUS = 'HELP: Ctrl+S = Save | Ctrl+Q = Quit | Ctrl+W = Find | Ctrl+R = Replace | Ctrl+L = Go to Line';
 /**
  * Main editor class managing application state, TTY interaction, and rendering.
@@ -44,6 +45,7 @@ export class CliEditor {
         // Map<lineNumber, Array<{ start, end }>> for fast rendering lookup
         this.searchResultMap = new Map();
         this.searchResultIndex = -1;
+        this.syntaxCache = new Map();
         this.isCleanedUp = false;
         this.resolvePromise = null;
         this.rejectPromise = null;
@@ -145,3 +147,4 @@ Object.assign(CliEditor.prototype, historyMethods);
 Object.assign(CliEditor.prototype, ioMethods);
 Object.assign(CliEditor.prototype, keyHandlingMethods);
 Object.assign(CliEditor.prototype, selectionMethods);
+Object.assign(CliEditor.prototype, syntaxMethods);

package/dist/editor.keys.js

@@ -80,11 +80,15 @@ function handleKeypressEvent(ch, key) {
         else if (key.name === 'return')
             keyName = KEYS.ENTER;
         else if (key.name === 'tab')
-            keyName = KEYS.TAB;
+            keyName = key.shift ? KEYS.SHIFT_TAB : KEYS.TAB;
         else if (key.meta && key.name === 'left')
             keyName = 'ALT_LEFT';
         else if (key.meta && key.name === 'right')
             keyName = 'ALT_RIGHT';
+        else if (key.meta && key.name === 'up')
+            keyName = KEYS.ALT_UP;
+        else if (key.meta && key.name === 'down')
+            keyName = KEYS.ALT_DOWN;
         // Handle Mouse Scroll events explicitly
         else if (key.name === 'scrollup')
             keyName = 'SCROLL_UP';
@@ -277,8 +281,30 @@ function handleEditKeys(key) {
             return true;
         case KEYS.TAB:
             this.clearSearchResults();
-            this.insertSoftTab();
-            return true;
+            if (this.selectionAnchor) {
+                this.indentSelection();
+                return false; // Manually saved state
+            }
+            else {
+                this.insertSoftTab();
+                return true;
+            }
+        case KEYS.SHIFT_TAB:
+            this.clearSearchResults();
+            this.outdentSelection();
+            return false; // Manually saved state
+        case KEYS.ALT_UP:
+            this.clearSearchResults();
+            this.moveLines(-1);
+            return false; // Manually saved state
+        case KEYS.ALT_DOWN:
+            this.clearSearchResults();
+            this.moveLines(1);
+            return false; // Manually saved state
+        case KEYS.CTRL_D:
+            this.clearSearchResults();
+            this.duplicateLineOrSelection();
+            return false; // Manually saved state
         // --- Search & History ---
         case KEYS.CTRL_W:
             this.enterFindMode();

package/dist/editor.rendering.js

@@ -63,6 +63,9 @@ function render() {
                 : ' '.padStart(this.gutterWidth - 2, ' ') + ' | ';
             buffer += lineNumber;
             let lineContent = row.content;
+            // Retrieve syntax color map for the full logical line
+            // We pass the full line content because the scanner needs context
+            const syntaxColorMap = this.getLineSyntaxColor(row.logicalY, this.lines[row.logicalY]);
             // 2. Draw Content (Character by Character for selection/cursor)
             for (let i = 0; i < lineContent.length; i++) {
                 const char = lineContent[i];
@@ -87,6 +90,8 @@ function render() {
                     this.searchResults[this.searchResultIndex]?.y === logicalY &&
                     logicalX >= this.searchResults[this.searchResultIndex]?.x &&
                     logicalX < (this.searchResults[this.searchResultIndex]?.x + this.searchQuery.length));
+                // Syntax highlight color
+                const syntaxColor = syntaxColorMap.get(logicalX);
                 if (isSelected) {
                     buffer += ANSI.INVERT_COLORS + char + ANSI.RESET_COLORS;
                 }
@@ -102,6 +107,10 @@ function render() {
                     // Global Match: Invert only
                     buffer += ANSI.INVERT_COLORS + char + ANSI.RESET_COLORS;
                 }
+                else if (syntaxColor) {
+                    // Apply syntax color
+                    buffer += syntaxColor + char + ANSI.RESET_COLORS;
+                }
                 else {
                     buffer += char;
                 }

package/dist/editor.syntax.d.ts

@@ -0,0 +1,16 @@
+import { CliEditor } from './editor.js';
+/**
+ * Single-pass character scanner to generate a color map for a line.
+ * Implements "Poor Man's Syntax Highlighting" focusing on Brackets and Quotes.
+ */
+declare function getLineSyntaxColor(this: CliEditor, lineIndex: number, lineContent: string): Map<number, string>;
+/**
+ * Invalidates the syntax highlighting cache.
+ * Clears the entire cache to be safe and simple ("Poor Man's" approach).
+ */
+declare function invalidateSyntaxCache(this: CliEditor): void;
+export declare const syntaxMethods: {
+    getLineSyntaxColor: typeof getLineSyntaxColor;
+    invalidateSyntaxCache: typeof invalidateSyntaxCache;
+};
+export {};

package/dist/editor.syntax.js

@@ -0,0 +1,84 @@
+import { ANSI } from './constants.js';
+// Syntax colors
+const COLOR_BRACKET_1 = ANSI.YELLOW;
+const COLOR_STRING = ANSI.GREEN;
+// State constants
+const STATE_NORMAL = 0;
+const STATE_IN_STRING_SINGLE = 1; // '
+const STATE_IN_STRING_DOUBLE = 2; // "
+/**
+ * Single-pass character scanner to generate a color map for a line.
+ * Implements "Poor Man's Syntax Highlighting" focusing on Brackets and Quotes.
+ */
+function getLineSyntaxColor(lineIndex, lineContent) {
+    // Check cache first
+    if (this.syntaxCache.has(lineIndex)) {
+        return this.syntaxCache.get(lineIndex);
+    }
+    const colorMap = new Map();
+    let state = STATE_NORMAL;
+    for (let i = 0; i < lineContent.length; i++) {
+        const char = lineContent[i];
+        if (state === STATE_NORMAL) {
+            if (char === '"') {
+                state = STATE_IN_STRING_DOUBLE;
+                colorMap.set(i, COLOR_STRING);
+            }
+            else if (char === "'") {
+                state = STATE_IN_STRING_SINGLE;
+                colorMap.set(i, COLOR_STRING);
+            }
+            else if ('()[]{}'.includes(char)) {
+                // Alternate bracket colors for fun, or just use one
+                colorMap.set(i, COLOR_BRACKET_1);
+            }
+        }
+        else if (state === STATE_IN_STRING_DOUBLE) {
+            colorMap.set(i, COLOR_STRING);
+            if (char === '"') {
+                // Check if escaped
+                let backslashCount = 0;
+                for (let j = i - 1; j >= 0; j--) {
+                    if (lineContent[j] === '\\')
+                        backslashCount++;
+                    else
+                        break;
+                }
+                // Even backslashes => not escaped (e.g., \\" is literal backslash then quote)
+                // Odd backslashes => escaped (e.g., \" is literal quote)
+                if (backslashCount % 2 === 0) {
+                    state = STATE_NORMAL;
+                }
+            }
+        }
+        else if (state === STATE_IN_STRING_SINGLE) {
+            colorMap.set(i, COLOR_STRING);
+            if (char === "'") {
+                // Check if escaped
+                let backslashCount = 0;
+                for (let j = i - 1; j >= 0; j--) {
+                    if (lineContent[j] === '\\')
+                        backslashCount++;
+                    else
+                        break;
+                }
+                if (backslashCount % 2 === 0) {
+                    state = STATE_NORMAL;
+                }
+            }
+        }
+    }
+    this.syntaxCache.set(lineIndex, colorMap);
+    return colorMap;
+}
+/**
+ * Invalidates the syntax highlighting cache.
+ * Clears the entire cache to be safe and simple ("Poor Man's" approach).
+ */
+function invalidateSyntaxCache() {
+    this.syntaxCache.clear();
+}
+export const syntaxMethods = {
+    getLineSyntaxColor,
+    invalidateSyntaxCache
+};

package/dist/vendor/keypress.d.ts

@@ -1,6 +1,6 @@
 /**
- * Định nghĩa giao diện cho một sự kiện keypress.
- * Được điều chỉnh từ file editor.ts.
+ * Defines the interface for a keypress event.
+ * Adapted from the editor.ts file.
  */
 export interface KeypressEvent {
     name?: string;
@@ -11,7 +11,7 @@ export interface KeypressEvent {
     code?: string;
 }
 /**
- * Hàm chính, chấp nhận một Readable Stream và làm cho nó
- * phát ra sự kiện "keypress".
+ * Main function, accepts a Readable Stream and makes it
+ * emit "keypress" events.
  */
 export default function keypress(stream: NodeJS.ReadStream): void;

package/dist/vendor/keypress.js

@@ -1,11 +1,11 @@
 // src/vendor/keypress.ts
-// Đây là phiên bản "vendored" của thư viện 'keypress' (0.2.1)
-// được chuyển đổi sang TypeScript và loại bỏ hỗ trợ chuột
-// để tích hợp trực tiếp vào cliedit.
+// This is a "vendored" version of the 'keypress' library (0.2.1)
+// converted to TypeScript and stripped of mouse support
+// to be integrated directly into cliedit.
 import { EventEmitter } from 'events';
 import { StringDecoder } from 'string_decoder';
 /**
- * Hàm polyfill cho `EventEmitter.listenerCount()`, để tương thích ngược.
+ * Polyfill for `EventEmitter.listenerCount()`, for backward compatibility.
  */
 let listenerCount = EventEmitter.listenerCount;
 if (!listenerCount) {
@@ -14,19 +14,19 @@ if (!listenerCount) {
     };
 }
 /**
- * Regexes dùng để phân tích escape code của ansi
+ * Regexes used to parse ansi escape codes.
  */
 const metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
 const functionKeyCodeRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
 const mouseSgrRe = /^\x1b\[<(\d+);(\d+);(\d+)([mM])/;
 /**
- * Hàm chính, chấp nhận một Readable Stream và làm cho nó
- * phát ra sự kiện "keypress".
+ * Main function, accepts a Readable Stream and makes it
+ * emit "keypress" events.
  */
 export default function keypress(stream) {
     if (isEmittingKeypress(stream))
         return;
-    // Gắn decoder vào stream để theo dõi
+    // Attach decoder to the stream to monitor data
     stream._keypressDecoder = new StringDecoder('utf8');
     function onData(b) {
         if (listenerCount(stream, 'keypress') > 0) {
@@ -35,7 +35,7 @@ export default function keypress(stream) {
                 emitKey(stream, r);
         }
         else {
-            // Không ai đang nghe, gỡ bỏ listener
+            // No one is listening, remove listener
             stream.removeListener('data', onData);
             stream.on('newListener', onNewListener);
         }
@@ -54,23 +54,23 @@ export default function keypress(stream) {
     }
 }
 /**
- * Kiểm tra xem stream đã phát ra sự kiện "keypress" hay chưa.
+ * Checks if the stream has already emitted the "keypress" event.
  */
 function isEmittingKeypress(stream) {
     let rtn = !!stream._keypressDecoder;
     if (!rtn) {
-        // XXX: Đối với các phiên bản node cũ, chúng ta muốn xóa các
-        // listener "data" và "newListener" hiện có vì chúng sẽ không
-        // bao gồm các phần mở rộng của module này (như "mousepress" đã bị loại bỏ).
+        // XXX: For older node versions, we want to remove existing
+        // "data" and "newListener" listeners because they won't
+        // include extensions from this module (like "mousepress" which was removed).
         stream.listeners('data').slice(0).forEach(function (l) {
             if (l.name === 'onData' && /emitKey/.test(l.toString())) {
-                // FIX TS2769: Ép kiểu 'l' thành kiểu listener hợp lệ
+                // FIX TS2769: Cast 'l' to a valid listener type
                 stream.removeListener('data', l);
             }
         });
         stream.listeners('newListener').slice(0).forEach(function (l) {
             if (l.name === 'onNewListener' && /keypress/.test(l.toString())) {
-                // FIX TS2769: Ép kiểu 'l' thành kiểu listener hợp lệ
+                // FIX TS2769: Cast 'l' to a valid listener type
                 stream.removeListener('newListener', l);
             }
         });
@@ -78,8 +78,8 @@ function isEmittingKeypress(stream) {
     return rtn;
 }
 /**
- * Phần code bên dưới được lấy từ module `readline.js` của node-core
- * và đã được chuyển đổi sang TypeScript.
+ * The code below is taken from node-core's `readline.js` module
+ * and has been converted to TypeScript.
  */
 function emitKey(stream, s) {
     let ch;
@@ -91,16 +91,16 @@ function emitKey(stream, s) {
         sequence: s,
     };
     let parts;
-    // Cảnh báo: Block `Buffer.isBuffer(s)` đã bị loại bỏ.
-    // Lý do: `onData` luôn gọi `emitKey` với một string (kết quả từ StringDecoder).
-    // Block đệ quy (paste) cũng gọi với string.
-    // Vì vậy, `s` luôn là string.
+    // Warning: The `Buffer.isBuffer(s)` block has been removed.
+    // Reason: `onData` always calls `emitKey` with a string (result from StringDecoder).
+    // The recursive block (paste) also calls with a string.
+    // Therefore, `s` is always a string.
     if (s === '\r') {
         // carriage return
         key.name = 'return';
     }
     else if (s === '\n') {
-        // enter, đáng lẽ phải là linefeed
+        // enter, should have been linefeed
         key.name = 'enter';
     }
     else if (s === '\t') {
@@ -111,7 +111,7 @@ function emitKey(stream, s) {
         s === '\x7f' ||
         s === '\x1b\x7f' ||
         s === '\x1b\b') {
-        // backspace hoặc ctrl+h
+        // backspace or ctrl+h
         key.name = 'backspace';
         key.meta = s.charAt(0) === '\x1b';
     }
@@ -156,20 +156,20 @@ function emitKey(stream, s) {
     }
     else if ((parts = functionKeyCodeRe.exec(s))) {
         // ansi escape sequence
-        // Lắp ráp lại key code, bỏ qua \x1b đứng đầu,
-        // bitflag của phím bổ trợ và bất kỳ chuỗi "1;" vô nghĩa nào
+        // Reassemble key code, ignoring leading \x1b,
+        // modifier bitflag, and any meaningless "1;" strings
         const code = (parts[1] || '') +
             (parts[2] || '') +
             (parts[4] || '') +
             (parts[6] || '');
-        // FIX TS2362: Chuyển đổi (parts[...]) sang number bằng parseInt
+        // FIX TS2362: Convert (parts[...]) to number using parseInt
         const modifier = parseInt(parts[3] || parts[5] || '1', 10) - 1;
-        // Phân tích phím bổ trợ
+        // Parse modifier keys
         key.ctrl = !!(modifier & 4);
         key.meta = !!(modifier & 10);
         key.shift = !!(modifier & 1);
         key.code = code;
-        // Phân tích chính phím đó
+        // Parse the key itself
         switch (code) {
             /* xterm/gnome ESC O letter */
             case 'OP':
@@ -415,8 +415,8 @@ function emitKey(stream, s) {
         }
     }
     else if (s.length > 1 && s[0] !== '\x1b') {
-        // Nhận được một chuỗi ký tự dài hơn một.
-        // Có thể là paste, vì nó không phải là control sequence.
+        // Received a string longer than one character.
+        // Could be a paste, since it's not a control sequence.
         for (const c of s) {
             emitKey(stream, c);
         }
@@ -448,7 +448,7 @@ function emitKey(stream, s) {
         // We can handle click here if needed (b=0 left, b=1 middle, b=2 right)
         // but for now only scroll is requested.
     }
-    // Không phát ra key nếu không tìm thấy tên
+    // Don't emit key if name is not found
     if (key.name === undefined) {
         return; // key = undefined;
     }

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "cliedit",
-  "version": "0.3.0",
-  "description": "A lightweight, raw-mode terminal editor utility for Node.js CLI applications, with line wrapping and undo/redo support.",
-  "repository": "https://github.com/CodeTease/cliedit",
+  "version": "0.4.0",
+  "description": "A zero-dependency, embeddable TUI text editor for Node.js CLI applications.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodeTease/cliedit.git"
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",