cliedit 0.1.0

package/dist/editor.navigation.js

@@ -0,0 +1,132 @@
+// src/editor.navigation.ts
+/**
+ * Methods related to cursor movement and viewport scrolling.
+ */
+/**
+ * Finds the index of the visual row that currently contains the cursor.
+ */
+function findCurrentVisualRowIndex() {
+    const contentWidth = this.screenCols - this.gutterWidth;
+    if (contentWidth <= 0)
+        return 0;
+    // Find the visual row index corresponding to the logical cursor position (cursorY, cursorX)
+    for (let i = 0; i < this.visualRows.length; i++) {
+        const row = this.visualRows[i];
+        if (row.logicalY === this.cursorY) {
+            // Check if cursorX falls within this visual row's content chunk
+            if (this.cursorX >= row.logicalXStart &&
+                this.cursorX <= row.logicalXStart + row.content.length) {
+                // Edge case: If cursorX is exactly at the start of a wrapped line (and not start of logical line), 
+                // treat it as the end of the previous visual row for consistent movement.
+                if (this.cursorX > 0 && this.cursorX === row.logicalXStart && i > 0) {
+                    return i - 1;
+                }
+                return i;
+            }
+        }
+        // Optimization: if we've passed the cursor's logical line, the row must be the last one processed.
+        if (row.logicalY > this.cursorY) {
+            return i - 1;
+        }
+    }
+    return Math.max(0, this.visualRows.length - 1);
+}
+/**
+ * Moves the cursor one position left or right (logically, wrapping lines).
+ */
+function moveCursorLogically(dx) {
+    if (dx === -1) {
+        if (this.cursorX > 0) {
+            this.cursorX--;
+        }
+        else if (this.cursorY > 0) {
+            this.cursorY--;
+            this.cursorX = this.lines[this.cursorY].length;
+        }
+    }
+    else if (dx === 1) {
+        const lineLength = this.lines[this.cursorY].length;
+        if (this.cursorX < lineLength) {
+            this.cursorX++;
+        }
+        else if (this.cursorY < this.lines.length - 1) {
+            this.cursorY++;
+            this.cursorX = 0;
+        }
+    }
+}
+/**
+ * Moves the cursor up or down by visual rows (dy).
+ */
+function moveCursorVisually(dy) {
+    const currentVisualRow = this.findCurrentVisualRowIndex();
+    const targetVisualRow = Math.max(0, Math.min(currentVisualRow + dy, this.visualRows.length - 1));
+    if (currentVisualRow === targetVisualRow)
+        return;
+    const targetRow = this.visualRows[targetVisualRow];
+    // Calculate the cursor's visual column position relative to its visual row start
+    const currentVisualX = this.cursorX - (this.visualRows[currentVisualRow]?.logicalXStart || 0);
+    this.cursorY = targetRow.logicalY;
+    // Maintain the visual column position as closely as possible
+    this.cursorX = Math.min(targetRow.logicalXStart + currentVisualX, this.lines[this.cursorY].length);
+}
+/**
+ * Finds the start of the current visual line (Home key behavior).
+ */
+function findVisualRowStart() {
+    const visualRow = this.visualRows[this.findCurrentVisualRowIndex()];
+    return visualRow.logicalXStart;
+}
+/**
+ * Finds the end of the current visual line (End key behavior).
+ */
+function findVisualRowEnd() {
+    const visualRow = this.visualRows[this.findCurrentVisualRowIndex()];
+    const lineLength = this.lines[visualRow.logicalY].length;
+    const contentWidth = this.screenCols - this.gutterWidth;
+    // The visual end is the start of the visual row + the maximum content width
+    const visualEnd = visualRow.logicalXStart + contentWidth;
+    // The actual logical X should be the minimum of the line's end and the visual end
+    return Math.min(lineLength, visualEnd);
+}
+/**
+ * Clamps the cursor position to valid coordinates and ensures it stays within line bounds.
+ */
+function adjustCursorPosition() {
+    // Clamp Y
+    if (this.cursorY < 0)
+        this.cursorY = 0;
+    if (this.cursorY >= this.lines.length) {
+        this.cursorY = Math.max(0, this.lines.length - 1);
+    }
+    // Clamp X
+    const lineLength = this.lines[this.cursorY]?.length || 0;
+    if (this.cursorX < 0)
+        this.cursorX = 0;
+    if (this.cursorX > lineLength) {
+        this.cursorX = lineLength;
+    }
+}
+/**
+ * Scrolls the viewport to keep the cursor visible.
+ */
+function scroll() {
+    const currentVisualRow = this.findCurrentVisualRowIndex();
+    // Scroll up
+    if (currentVisualRow < this.rowOffset) {
+        this.rowOffset = currentVisualRow;
+    }
+    // Scroll down
+    if (currentVisualRow >= this.rowOffset + this.screenRows) {
+        this.rowOffset = currentVisualRow - this.screenRows + 1;
+    }
+}
+export const navigationMethods = {
+    findCurrentVisualRowIndex,
+    moveCursorLogically,
+    moveCursorVisually,
+    findVisualRowStart,
+    findVisualRowEnd,
+    adjustCursorPosition,
+    scroll,
+};

package/dist/editor.rendering.d.ts

@@ -0,0 +1,27 @@
+import { CliEditor } from './editor.js';
+/**
+ * Core methods for rendering the document content, status bar, and cursor.
+ */
+/**
+ * Recalculates the entire visual layout of the document based on screen width (line wrapping).
+ */
+declare function recalculateVisualRows(this: CliEditor): void;
+/**
+ * The main rendering loop.
+ */
+declare function render(this: CliEditor): void;
+/**
+ * Sets the status message and handles the timeout for custom messages.
+ */
+declare function setStatusMessage(this: CliEditor, message: string, timeoutMs?: number): void;
+/**
+ * Generates the status bar content (bottom two lines).
+ */
+declare function renderStatusBar(this: CliEditor): string;
+export declare const renderingMethods: {
+    recalculateVisualRows: typeof recalculateVisualRows;
+    render: typeof render;
+    setStatusMessage: typeof setStatusMessage;
+    renderStatusBar: typeof renderStatusBar;
+};
+export {};

package/dist/editor.rendering.js

@@ -0,0 +1,152 @@
+// src/editor.rendering.ts
+import { ANSI } from './constants.js';
+/**
+ * Core methods for rendering the document content, status bar, and cursor.
+ */
+/**
+ * Recalculates the entire visual layout of the document based on screen width (line wrapping).
+ */
+function recalculateVisualRows() {
+    this.visualRows = [];
+    // Calculate content width excluding gutter
+    const contentWidth = Math.max(1, this.screenCols - this.gutterWidth);
+    for (let y = 0; y < this.lines.length; y++) {
+        const line = this.lines[y];
+        if (line.length === 0) {
+            // Handle empty line case
+            this.visualRows.push({ logicalY: y, logicalXStart: 0, content: '' });
+        }
+        else {
+            let x = 0;
+            // Chunk the line content based on contentWidth
+            while (x < line.length) {
+                const chunk = line.substring(x, x + contentWidth);
+                this.visualRows.push({ logicalY: y, logicalXStart: x, content: chunk });
+                x += contentWidth;
+            }
+        }
+    }
+}
+/**
+ * The main rendering loop.
+ */
+function render() {
+    this.adjustCursorPosition();
+    this.scroll();
+    let buffer = ANSI.MOVE_CURSOR_TOP_LEFT;
+    const currentVisualRowIndex = this.findCurrentVisualRowIndex();
+    const cursorVisualRow = this.visualRows[currentVisualRowIndex];
+    const cursorVisualX = cursorVisualRow ? (this.cursorX - cursorVisualRow.logicalXStart) : 0;
+    // Determine where the physical cursor should be placed
+    const displayX = cursorVisualX + this.gutterWidth;
+    const displayY = this.screenStartRow + (currentVisualRowIndex - this.rowOffset);
+    const selectionRange = this.getNormalizedSelection();
+    // Draw visual rows
+    for (let y = 0; y < this.screenRows; y++) {
+        const visualRowIndex = y + this.rowOffset;
+        // Move to start of the row
+        buffer += `\x1b[${this.screenStartRow + y};1H`;
+        if (visualRowIndex >= this.visualRows.length) {
+            // Draw Tilde for lines past file end
+            buffer += `~ ${ANSI.CLEAR_LINE}`;
+        }
+        else {
+            const row = this.visualRows[visualRowIndex];
+            // 1. Draw Gutter (Line Number)
+            const lineNumber = (row.logicalXStart === 0)
+                ? `${row.logicalY + 1}`.padStart(this.gutterWidth - 2, ' ') + ' | '
+                : ' '.padStart(this.gutterWidth - 2, ' ') + ' | ';
+            buffer += lineNumber;
+            let lineContent = row.content;
+            // 2. Draw Content (Character by Character for selection/cursor)
+            for (let i = 0; i < lineContent.length; i++) {
+                const char = lineContent[i];
+                const logicalX = row.logicalXStart + i;
+                const logicalY = row.logicalY;
+                const isCursorPosition = (visualRowIndex === currentVisualRowIndex && i === cursorVisualX);
+                const isSelected = selectionRange && this.isPositionInSelection(logicalY, logicalX, selectionRange);
+                if (isSelected) {
+                    buffer += ANSI.INVERT_COLORS + char + ANSI.RESET_COLORS;
+                }
+                else if (isCursorPosition) {
+                    // Cursor is a single inverted character if not already covered by selection
+                    buffer += ANSI.INVERT_COLORS + char + ANSI.RESET_COLORS;
+                }
+                else {
+                    buffer += char;
+                }
+            }
+            // 3. Handle Cursor at the absolute end of the line (drawing an inverted space)
+            const isCursorAtEndOfVisualLine = (visualRowIndex === currentVisualRowIndex && cursorVisualX === lineContent.length);
+            if (isCursorAtEndOfVisualLine) {
+                // If the cursor is at the end of the line/chunk, draw the inverted space
+                buffer += ANSI.INVERT_COLORS + ' ' + ANSI.RESET_COLORS;
+            }
+            buffer += `${ANSI.CLEAR_LINE}`;
+        }
+    }
+    // Draw status bar
+    buffer += `\x1b[${this.screenRows + this.screenStartRow};1H`;
+    buffer += this.renderStatusBar();
+    // Set physical cursor position (ensure cursor is visible on screen)
+    if (displayY >= this.screenStartRow && displayY < this.screenRows + this.screenStartRow) {
+        buffer += `\x1b[${displayY};${displayX + 1}H`;
+    }
+    process.stdout.write(buffer);
+}
+/**
+ * Sets the status message and handles the timeout for custom messages.
+ */
+function setStatusMessage(message, timeoutMs = 3000) {
+    this.statusMessage = message;
+    this.isMessageCustom = message !== this.DEFAULT_STATUS;
+    if (this.statusTimeout) {
+        clearTimeout(this.statusTimeout);
+        this.statusTimeout = null;
+    }
+    if (message !== this.DEFAULT_STATUS && timeoutMs > 0) {
+        this.statusTimeout = setTimeout(() => {
+            this.statusMessage = this.DEFAULT_STATUS;
+            this.isMessageCustom = false;
+            this.statusTimeout = null;
+            if (!this.isCleanedUp)
+                this.renderStatusBar();
+        }, timeoutMs);
+    }
+    if (!this.isCleanedUp)
+        this.renderStatusBar();
+}
+/**
+ * Generates the status bar content (bottom two lines).
+ */
+function renderStatusBar() {
+    let status = '';
+    const contentWidth = this.screenCols;
+    // --- Line 1: Mode, File Status, Position ---
+    if (this.mode === 'search') {
+        status = `SEARCH: ${this.searchQuery}`;
+    }
+    else {
+        const visualRowIndex = this.findCurrentVisualRowIndex();
+        const visualRow = this.visualRows[visualRowIndex];
+        const visualX = visualRow ? (this.cursorX - visualRow.logicalXStart) : 0;
+        const fileStatus = this.isDirty ? `* ${this.filepath}` : this.filepath;
+        const pos = `Ln ${this.cursorY + 1}, Col ${this.cursorX + 1} (View: ${visualRowIndex + 1},${visualX + 1})`;
+        const statusLeft = `[${fileStatus}]`.padEnd(Math.floor(contentWidth * 0.5));
+        const statusRight = pos.padStart(Math.floor(contentWidth * 0.5));
+        status = statusLeft + statusRight;
+    }
+    status = status.padEnd(contentWidth);
+    let buffer = `${ANSI.INVERT_COLORS}${status}${ANSI.RESET_COLORS}`;
+    // --- Line 2: Message/Help line ---
+    buffer += `\x1b[${this.screenRows + this.screenStartRow + 1};1H`;
+    const message = this.statusMessage.padEnd(contentWidth);
+    buffer += `${message}${ANSI.CLEAR_LINE}`;
+    return buffer;
+}
+export const renderingMethods = {
+    recalculateVisualRows,
+    render,
+    setStatusMessage,
+    renderStatusBar,
+};

package/dist/editor.search.d.ts

@@ -0,0 +1,30 @@
+import { CliEditor } from './editor.js';
+/**
+ * Methods related to Find/Search functionality.
+ */
+/**
+ * Enters search mode.
+ */
+declare function enterSearchMode(this: CliEditor): void;
+/**
+ * Executes the search and populates results.
+ */
+declare function executeSearch(this: CliEditor): void;
+/**
+ * Jumps to the next search result.
+ */
+declare function findNext(this: CliEditor): void;
+/**
+ * Moves cursor and adjusts scroll offset to make the result visible.
+ */
+declare function jumpToResult(this: CliEditor, result: {
+    y: number;
+    x: number;
+}): void;
+export declare const searchMethods: {
+    enterSearchMode: typeof enterSearchMode;
+    executeSearch: typeof executeSearch;
+    findNext: typeof findNext;
+    jumpToResult: typeof jumpToResult;
+};
+export {};

package/dist/editor.search.js

@@ -0,0 +1,58 @@
+// src/editor.search.ts
+/**
+ * Methods related to Find/Search functionality.
+ */
+/**
+ * Enters search mode.
+ */
+function enterSearchMode() {
+    this.mode = 'search';
+    this.searchQuery = '';
+    this.searchResults = [];
+    this.searchResultIndex = -1;
+    this.setStatusMessage('Search (ESC/Ctrl+Q/C to cancel, ENTER to find): ');
+}
+/**
+ * Executes the search and populates results.
+ */
+function executeSearch() {
+    this.searchResults = [];
+    if (this.searchQuery === '')
+        return;
+    for (let y = 0; y < this.lines.length; y++) {
+        const line = this.lines[y];
+        let index = -1;
+        while ((index = line.indexOf(this.searchQuery, index + 1)) !== -1) {
+            this.searchResults.push({ y, x: index });
+        }
+    }
+    this.searchResultIndex = -1;
+    this.setStatusMessage(`Found ${this.searchResults.length} results for "${this.searchQuery}"`);
+}
+/**
+ * Jumps to the next search result.
+ */
+function findNext() {
+    if (this.searchResults.length === 0) {
+        this.setStatusMessage('No search results');
+        return;
+    }
+    this.searchResultIndex = (this.searchResultIndex + 1) % this.searchResults.length;
+    this.jumpToResult(this.searchResults[this.searchResultIndex]);
+}
+/**
+ * Moves cursor and adjusts scroll offset to make the result visible.
+ */
+function jumpToResult(result) {
+    this.cursorY = result.y;
+    this.cursorX = result.x;
+    const visualRowIndex = this.findCurrentVisualRowIndex();
+    // Calculate new scroll offset to center the result visually
+    this.rowOffset = Math.max(0, visualRowIndex - Math.floor(this.screenRows / 2));
+}
+export const searchMethods = {
+    enterSearchMode,
+    executeSearch,
+    findNext,
+    jumpToResult,
+};

package/dist/editor.selection.d.ts

@@ -0,0 +1,19 @@
+export type NormalizedRange = {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+};
+export type TSelectionMethods = {
+    startOrUpdateSelection: () => void;
+    cancelSelection: () => void;
+    getNormalizedSelection: () => NormalizedRange | null;
+    isPositionInSelection: (logicalY: number, logicalX: number, range: NormalizedRange) => boolean;
+    getSelectedText: () => string;
+    deleteSelectedText: () => void;
+};
+export declare const selectionMethods: TSelectionMethods;

package/dist/editor.selection.js

@@ -0,0 +1,118 @@
+// src/editor.selection.ts
+/**
+ * Methods related to Text Selection management.
+ */
+/**
+ * Starts or updates the selection anchor.
+ */
+function startOrUpdateSelection() {
+    if (!this.selectionAnchor) {
+        this.selectionAnchor = { x: this.cursorX, y: this.cursorY };
+    }
+    // If it exists, we just let the cursor move to update the selection end point.
+}
+/**
+ * Cancels the current selection.
+ */
+function cancelSelection() {
+    this.selectionAnchor = null;
+}
+/**
+ * Returns the selection range with 'start' always before 'end' (normalized).
+ */
+function getNormalizedSelection() {
+    if (!this.selectionAnchor)
+        return null;
+    const p1 = this.selectionAnchor;
+    const p2 = { x: this.cursorX, y: this.cursorY };
+    if (p1.y < p2.y || (p1.y === p2.y && p1.x < p2.x)) {
+        return { start: p1, end: p2 };
+    }
+    else {
+        return { start: p2, end: p1 };
+    }
+}
+/**
+ * Checks if a logical position (Y, X) is inside the normalized selection range.
+ */
+function isPositionInSelection(logicalY, logicalX, range) {
+    if (logicalY < range.start.y || logicalY > range.end.y)
+        return false;
+    // Check if the position is on the start line
+    if (logicalY === range.start.y && logicalX < range.start.x)
+        return false;
+    // Check if the position is on the end line
+    // The position is INCLUDED until it hits the end x-coordinate
+    if (logicalY === range.end.y && logicalX >= range.end.x)
+        return false;
+    return true;
+}
+/**
+ * Extracts the selected text.
+ */
+function getSelectedText() {
+    const range = this.getNormalizedSelection();
+    if (!range)
+        return '';
+    let selectedLines = [];
+    for (let y = range.start.y; y <= range.end.y; y++) {
+        const line = this.lines[y] || '';
+        let startX = (y === range.start.y) ? range.start.x : 0;
+        let endX = (y === range.end.y) ? range.end.x : line.length;
+        // Ensure we don't try to select past the actual line length
+        endX = Math.min(endX, line.length);
+        if (startX < endX) {
+            selectedLines.push(line.substring(startX, endX));
+        }
+        else if (y === range.start.y && range.start.y === range.end.y && startX === endX) {
+            // Handle case where selection is zero-width, but on the same line (empty string)
+        }
+        else if (y < range.end.y) {
+            // If it's an empty line that is fully included in the selection
+            selectedLines.push('');
+        }
+    }
+    // Join the extracted lines
+    return selectedLines.join('\n');
+}
+/**
+ * Deletes the currently selected text, adjusting the cursor position.
+ * Returns true if deletion occurred.
+ */
+function deleteSelectedText() {
+    const range = this.getNormalizedSelection();
+    if (!range)
+        return false;
+    const { start, end } = range;
+    // 1. Join the remaining parts:
+    //    Part 1: Start line content before selection start
+    const startLineContent = this.lines[start.y].substring(0, start.x);
+    //    Part 2: End line content after selection end
+    const endLineContent = this.lines[end.y].substring(end.x);
+    // 2. Set the content of the start line to the joined content
+    this.lines[start.y] = startLineContent + endLineContent;
+    // 3. Remove all lines between start.y and end.y (exclusive)
+    const linesToDeleteCount = end.y - start.y;
+    if (linesToDeleteCount > 0) {
+        this.lines.splice(start.y + 1, linesToDeleteCount);
+    }
+    // 4. Update cursor position (it moves to the start of the former selection)
+    this.cursorY = start.y;
+    this.cursorX = start.x;
+    // 5. Clear selection
+    this.cancelSelection();
+    this.setDirty();
+    // 6. Ensure we didn't accidentally make the document empty
+    if (this.lines.length === 0) {
+        this.lines = [''];
+    }
+    return true;
+}
+export const selectionMethods = {
+    startOrUpdateSelection,
+    cancelSelection,
+    getNormalizedSelection,
+    isPositionInSelection,
+    getSelectedText,
+    deleteSelectedText,
+};

package/dist/history.d.ts

@@ -0,0 +1,28 @@
+import { DocumentState } from './types.js';
+/**
+ * Manages the undo/redo history stack for the editor.
+ */
+export declare class HistoryManager {
+    private undoHistory;
+    private redoHistory;
+    private readonly historyLimit;
+    constructor(historyLimit?: number);
+    /**
+     * Saves the current state to the undo history.
+     * This clears the redo history.
+     */
+    saveState(state: DocumentState): void;
+    /**
+     * Performs an undo operation.
+     * @param currentState The state *before* undoing, to save to redo stack.
+     * @returns The state to restore (DocumentState) or null if no history.
+     */
+    undo(currentState: DocumentState): DocumentState | null;
+    /**
+     * Performs a redo operation.
+     * @param currentState The state *before* redoing, to save to undo stack.
+     * @returns The state to restore (DocumentState) or null if no history.
+     */
+    redo(currentState: DocumentState): DocumentState | null;
+    clear(): void;
+}

package/dist/history.js

@@ -0,0 +1,57 @@
+// src/history.ts
+/**
+ * Manages the undo/redo history stack for the editor.
+ */
+export class HistoryManager {
+    constructor(historyLimit = 100) {
+        this.undoHistory = [];
+        this.redoHistory = [];
+        this.historyLimit = historyLimit;
+    }
+    /**
+     * Saves the current state to the undo history.
+     * This clears the redo history.
+     */
+    saveState(state) {
+        // Clear redo history on new action
+        this.redoHistory = [];
+        // Add to undo history
+        this.undoHistory.push(state);
+        // Maintain history limit
+        if (this.undoHistory.length > this.historyLimit) {
+            this.undoHistory.shift();
+        }
+    }
+    /**
+     * Performs an undo operation.
+     * @param currentState The state *before* undoing, to save to redo stack.
+     * @returns The state to restore (DocumentState) or null if no history.
+     */
+    undo(currentState) {
+        const previousState = this.undoHistory.pop();
+        if (!previousState) {
+            return null; // Nothing to undo
+        }
+        // Save current state to redo stack
+        this.redoHistory.push(currentState);
+        return previousState;
+    }
+    /**
+     * Performs a redo operation.
+     * @param currentState The state *before* redoing, to save to undo stack.
+     * @returns The state to restore (DocumentState) or null if no history.
+     */
+    redo(currentState) {
+        const nextState = this.redoHistory.pop();
+        if (!nextState) {
+            return null; // Nothing to redo
+        }
+        // Save current (undone) state back to undo stack
+        this.undoHistory.push(currentState);
+        return nextState;
+    }
+    clear() {
+        this.undoHistory = [];
+        this.redoHistory = [];
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Public API function: Opens the editor.
+ * Reads the file and initializes CliEditor.
+ */
+export declare function openEditor(filepath: string): Promise<{
+    saved: boolean;
+    content: string;
+}>;
+export { CliEditor } from './editor.js';
+export type { DocumentState, VisualRow, EditorMode } from './types.js';
+export type { NormalizedRange } from './editor.selection.js';

package/dist/index.js

@@ -0,0 +1,26 @@
+// src/index.ts
+import { promises as fs } from 'fs';
+import { CliEditor } from './editor.js';
+/**
+ * Public API function: Opens the editor.
+ * Reads the file and initializes CliEditor.
+ */
+export async function openEditor(filepath) {
+    let initialContent = '';
+    try {
+        // 1. Read file
+        initialContent = await fs.readFile(filepath, 'utf-8');
+    }
+    catch (err) {
+        // 2. If file does not exist (ENOENT), treat it as a new file
+        if (err.code !== 'ENOENT') {
+            throw err; // Throw error if not 'File not found'
+        }
+    }
+    // 3. Initialize and run editor
+    const editor = new CliEditor(initialContent, filepath);
+    return editor.run();
+}
+// --- Public Exports ---
+// Export the main class for advanced users
+export { CliEditor } from './editor.js';

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Defines the necessary state for saving and restoring the document content
+ * and cursor position for the History Manager (Undo/Redo).
+ */
+export type DocumentState = {
+    lines: string[];
+    cursorX: number;
+    cursorY: number;
+};
+/**
+ * Defines a row as it is displayed on the terminal (after line wrapping).
+ */
+export interface VisualRow {
+    logicalY: number;
+    logicalXStart: number;
+    content: string;
+}
+export type EditorMode = 'edit' | 'search';

package/dist/types.js

@@ -0,0 +1,2 @@
+// src/types.ts
+export {};