voonex 0.1.0

package/dist/core/Screen.js

@@ -0,0 +1,373 @@
+"use strict";
+// ==========================================
+// CORE: SCREEN MANAGER (The "Canvas")
+// ==========================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Screen = void 0;
+const Cursor_1 = require("./Cursor");
+class Screen {
+    /**
+     * Enters the Alternate Screen Buffer (like Vim or Nano).
+     */
+    static enter() {
+        if (this.isAlternateBuffer)
+            return;
+        process.stdout.write('\x1b[?1049h'); // Enter alternate buffer
+        Cursor_1.Cursor.hide();
+        this.isAlternateBuffer = true;
+        this.resizeBuffers();
+        // Removed startLoop(), now using reactive rendering
+        this.onResize(() => {
+            this.resizeBuffers();
+            this.scheduleRender();
+        });
+    }
+    /**
+     * Leaves the Alternate Screen Buffer and restores cursor.
+     */
+    static leave() {
+        if (!this.isAlternateBuffer)
+            return;
+        // Removed stopLoop()
+        Cursor_1.Cursor.show();
+        process.stdout.write('\x1b[?1049l'); // Leave alternate buffer
+        this.isAlternateBuffer = false;
+    }
+    static resizeBuffers() {
+        this.width = process.stdout.columns || 80;
+        this.height = process.stdout.rows || 24;
+        // Initialize or Resize Buffers
+        this.currentBuffer = Array(this.height).fill(null).map(() => Array(this.width).fill(null).map(() => ({ char: ' ', style: '' })));
+        this.previousBuffer = Array(this.height).fill(null).map(() => Array(this.width).fill(null).map(() => ({ char: ' ', style: '' })));
+        // Mark all rows as dirty to ensure full initial render
+        this.dirtyRows = Array(this.height).fill(true);
+    }
+    /**
+     * Schedules a render flush in the next tick.
+     * Call this whenever a component changes state.
+     */
+    static scheduleRender() {
+        if (this.renderScheduled)
+            return;
+        this.renderScheduled = true;
+        // Use setImmediate to batch updates in the same tick
+        setImmediate(() => {
+            this.flush();
+            this.renderScheduled = false;
+        });
+    }
+    /**
+     * Writes text at a specific coordinate into the virtual buffer.
+     * Handles ANSI escape codes using a state machine parser.
+     * Supports clipping region and relative positioning.
+     */
+    static write(x, y, text, clipRect) {
+        if (!this.isAlternateBuffer)
+            return;
+        // Apply Clipping Translation: (Relative -> Absolute)
+        let absX = x;
+        let absY = y;
+        if (clipRect) {
+            absX += clipRect.x;
+            absY += clipRect.y;
+        }
+        // Apply Clipping Bounds
+        const clipX1 = clipRect ? clipRect.x : 0;
+        const clipY1 = clipRect ? clipRect.y : 0;
+        const clipX2 = clipRect ? clipRect.x + clipRect.width : this.width;
+        const clipY2 = clipRect ? clipRect.y + clipRect.height : this.height;
+        if (absY < clipY1 || absY >= clipY2 || absY >= this.height)
+            return;
+        // Mark row as dirty
+        this.dirtyRows[absY] = true;
+        this.scheduleRender(); // Trigger render
+        let currentX = absX;
+        let currentStyle = "";
+        // ANSI State Machine Parser
+        let i = 0;
+        const len = text.length;
+        while (i < len) {
+            const char = text[i];
+            if (char === '\x1b') {
+                // Potential Escape Sequence
+                if (i + 1 < len && text[i + 1] === '[') {
+                    // ANSI Control Sequence Identifier (CSI)
+                    let j = i + 2;
+                    let code = "";
+                    // Read until 'm' or other terminator
+                    while (j < len) {
+                        const c = text[j];
+                        code += c;
+                        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
+                            break;
+                        }
+                        j++;
+                    }
+                    if (code.endsWith('m')) {
+                        // Color/Style Code
+                        const fullCode = `\x1b[${code}`;
+                        if (fullCode === '\x1b[0m' || fullCode === '\x1b[m') {
+                            currentStyle = "";
+                        }
+                        else {
+                            currentStyle += fullCode;
+                        }
+                    }
+                    i = j + 1;
+                    continue;
+                }
+            }
+            // Normal Character
+            // Check Clipping Horizontally
+            if (currentX >= clipX1 && currentX < clipX2 && currentX < this.width) {
+                this.currentBuffer[absY][currentX] = {
+                    char: char,
+                    style: currentStyle
+                };
+            }
+            currentX++;
+            i++;
+        }
+    }
+    /**
+     * Pushes the current screen state to a stack.
+     */
+    static pushLayer() {
+        const snapshot = this.currentBuffer.map(row => row.map(cell => ({ ...cell })));
+        this.layerStack.push(snapshot);
+    }
+    /**
+     * Restores the screen state from the stack.
+     */
+    static popLayer() {
+        const snapshot = this.layerStack.pop();
+        if (snapshot) {
+            if (snapshot.length === this.height && snapshot[0].length === this.width) {
+                this.currentBuffer = snapshot;
+                this.dirtyRows.fill(true);
+                this.scheduleRender();
+            }
+        }
+    }
+    /**
+     * Clears the virtual buffer.
+     */
+    static clear() {
+        if (!this.currentBuffer.length)
+            return;
+        for (let y = 0; y < this.height; y++) {
+            this.dirtyRows[y] = true;
+            for (let x = 0; x < this.width; x++) {
+                this.currentBuffer[y][x] = { char: ' ', style: '' };
+            }
+        }
+        this.scheduleRender();
+    }
+    /**
+     * Registers a root component for the rendering loop (Painter's Algorithm).
+     * @param renderFn The function that renders the component
+     * @param zIndex Priority (higher draws on top)
+     */
+    static mount(renderFn, zIndex = 0) {
+        this.renderRoots.push({ render: renderFn, zIndex });
+        this.renderRoots.sort((a, b) => a.zIndex - b.zIndex);
+        this.scheduleRender();
+    }
+    /**
+     * Unregisters a root component from the rendering loop.
+     * @param renderFn The function that renders the component
+     */
+    static unmount(renderFn) {
+        this.renderRoots = this.renderRoots.filter(r => r.render !== renderFn);
+        this.scheduleRender();
+    }
+    /**
+     * Diffs currentBuffer vs previousBuffer and writes changes to stdout.
+     * Optimized with String Batching and Relative Cursor Moves.
+     */
+    static flush() {
+        // Painter's Algorithm Phase: Re-run all render functions if any exist
+        // This clears the buffer and redraws everything from scratch (logically)
+        // But to keep performance, we might want to just let them draw over currentBuffer?
+        // User asked for: "1. Xóa Buffer ảo. 2. Duyệt qua danh sách...".
+        // If we have registered roots, we should follow this.
+        if (this.renderRoots.length > 0) {
+            // We need to clear currentBuffer effectively?
+            // Or maybe just let them overwrite. If transparency is involved, clearing is safer.
+            // But clearing everything is expensive if we just diff later. 
+            // The Diff algorithm handles the "screen update" optimization. 
+            // The "Virtual Buffer" update needs to be correct.
+            // If we have layers, and top layer moves, we need to redraw bottom layer to see what's behind.
+            // So YES, we must clear currentBuffer (or reset it to background state) and redraw all layers.
+            // Reset currentBuffer to empty/clean state WITHOUT affecting previousBuffer (screen state)
+            for (let y = 0; y < this.height; y++) {
+                for (let x = 0; x < this.width; x++) {
+                    this.currentBuffer[y][x] = { char: ' ', style: '' };
+                }
+                // We don't mark dirtyRows here blindly, we mark them if they CHANGE in the diff phase.
+                // Wait, dirtyRows optimization relies on us knowing which rows MIGHT have changed.
+                // If we clear everything, we potentially change everything.
+                // So we should mark all as dirty? 
+                // "Dirty" means "Virtual Buffer Row differs from Previous Buffer Row".
+                // Since we are rebuilding Virtual Buffer, we don't know yet.
+                // We should just run the diff loop on all rows?
+                // Or maybe we can track which rows are touched during render?
+            }
+            // Render all layers
+            for (const root of this.renderRoots) {
+                root.render();
+            }
+            // Mark all rows as dirty for the Diff phase to check them?
+            // Since we rebuilt the buffer, any row could be different from previousBuffer.
+            // Optimization: Maybe only rows that were touched? 
+            // But 'write' marks dirtyRows.
+            // So if we clear buffer (resetting chars), we are effectively writing spaces.
+            // If we use 'clear()' method, it marks all dirty.
+            // Let's rely on 'write' marking dirtyRows.
+            // But we just did manual reset loop above.
+            // Let's check:
+            // If we reset manual loop, we are changing 'currentBuffer'.
+            // Previous buffer holds what is on screen.
+            // If we don't mark dirtyRows, flush() skips the row.
+            // If screen has text, and we cleared it to spaces, and didn't mark dirty, screen stays text. Bad.
+            // So yes, we should mark all dirty if we do a full clear-redraw cycle.
+            this.dirtyRows.fill(true);
+        }
+        if (!this.currentBuffer.length)
+            return;
+        let output = "";
+        let lastY = -1;
+        let lastX = -1;
+        let lastStyle = "";
+        for (let y = 0; y < this.height; y++) {
+            if (!this.dirtyRows[y])
+                continue;
+            this.dirtyRows[y] = false;
+            let x = 0;
+            while (x < this.width) {
+                const cell = this.currentBuffer[y][x];
+                const prev = this.previousBuffer[y][x];
+                // Check for change
+                if (cell.char !== prev.char || cell.style !== prev.style) {
+                    // Update Previous Buffer
+                    this.previousBuffer[y][x] = { ...cell };
+                    // Move Cursor
+                    // Relative Move Optimization
+                    if (y === lastY && x === lastX + 1) {
+                        // Already at correct position
+                    }
+                    else if (y === lastY && x > lastX && x < lastX + 5) {
+                        // Close enough for right move
+                        const diff = x - (lastX + 1);
+                        if (diff > 0)
+                            output += `\x1b[${diff}C`;
+                        // If diff is 0 (next char), we do nothing.
+                        // Actually if x = lastX + 2, diff is 1. We need \x1b[1C.
+                    }
+                    else {
+                        // Absolute Move
+                        output += `\x1b[${y + 1};${x + 1}H`;
+                    }
+                    // Update Style
+                    if (cell.style !== lastStyle) {
+                        output += `\x1b[0m${cell.style}`;
+                        lastStyle = cell.style;
+                    }
+                    // String Batching: Look ahead for same style
+                    let batch = cell.char;
+                    let nextX = x + 1;
+                    while (nextX < this.width) {
+                        const nextCell = this.currentBuffer[y][nextX];
+                        const nextPrev = this.previousBuffer[y][nextX];
+                        // We only batch if the NEXT cell also NEEDS update AND has SAME style
+                        // Actually, even if next cell DOES NOT need update, 
+                        // if we write over it with same content, it's fine (redundant write but saves cursor move).
+                        // BUT, if we write over it, we might overwrite something valid with something else? 
+                        // No, currentBuffer is truth.
+                        // Strategy: 
+                        // 1. Only batch consecutive CHANGED cells?
+                        // 2. Or batch consecutive cells regardless, as long as style matches, to avoid cursor jumps?
+                        // If we skip a cell (not changed), we have to move cursor.
+                        // Moving cursor costs bytes (e.g. \x1b[C is 3 bytes).
+                        // Writing a char is 1 byte.
+                        // So overwriting valid char is cheaper than skipping 1-2 chars.
+                        // But if we skip 10 chars, move is cheaper.
+                        // Let's stick to simple logic: Only batch if next cell ALSO needs update OR we just overwrite it anyway to jump gap?
+                        // The user asked for "Gộp chuỗi ký tự liên tiếp có cùng style".
+                        // If we strictly follow diff, we only write changed cells.
+                        // So let's look for consecutive CHANGED cells with same style.
+                        if (nextCell.char !== nextPrev.char || nextCell.style !== nextPrev.style) {
+                            if (nextCell.style === cell.style) {
+                                batch += nextCell.char;
+                                // Update previous buffer as we consume
+                                this.previousBuffer[y][nextX] = { ...nextCell };
+                                nextX++;
+                            }
+                            else {
+                                break; // Style changed
+                            }
+                        }
+                        else {
+                            // Next cell is not changed.
+                            // Should we continue batching to bridge the gap?
+                            // If gap is small (1-2 chars), yes.
+                            // But that complicates logic. Let's stop batching.
+                            break;
+                        }
+                    }
+                    output += batch;
+                    lastY = y;
+                    lastX = x + batch.length - 1; // last written position
+                    x = nextX; // Continue loop
+                }
+                else {
+                    x++;
+                }
+            }
+        }
+        if (output.length > 0) {
+            // Reset style
+            // output += '\x1b[0m'; 
+            process.stdout.write(output);
+        }
+    }
+    /**
+     * Gets current terminal dimensions.
+     */
+    static get size() {
+        return {
+            width: process.stdout.columns || 80,
+            height: process.stdout.rows || 24
+        };
+    }
+    /**
+     * Listens for resize events.
+     */
+    static onResize(callback) {
+        process.stdout.on('resize', () => {
+            if (this.resizeTimeout) {
+                clearTimeout(this.resizeTimeout);
+            }
+            this.resizeTimeout = setTimeout(() => {
+                callback();
+            }, 100);
+        });
+    }
+}
+exports.Screen = Screen;
+Screen.isAlternateBuffer = false;
+Screen.resizeTimeout = null;
+// Double Buffering
+Screen.currentBuffer = [];
+Screen.previousBuffer = [];
+Screen.dirtyRows = [];
+// Layer Stack
+// Stores snapshots of the buffer before a new layer is added.
+Screen.layerStack = [];
+// Reactive Rendering
+Screen.isDirty = false;
+Screen.renderScheduled = false;
+Screen.width = 0;
+Screen.height = 0;
+// Component Registry for Layering (Painter's Algorithm)
+Screen.renderRoots = [];

package/dist/core/Styler.d.ts

@@ -0,0 +1,71 @@
+export declare const COLORS: {
+    readonly black: 30;
+    readonly red: 31;
+    readonly green: 32;
+    readonly yellow: 33;
+    readonly blue: 34;
+    readonly magenta: 35;
+    readonly cyan: 36;
+    readonly white: 37;
+    readonly gray: 90;
+    readonly brightRed: 91;
+    readonly brightGreen: 92;
+    readonly brightYellow: 93;
+    readonly brightBlue: 94;
+    readonly brightMagenta: 95;
+    readonly brightCyan: 96;
+    readonly brightWhite: 97;
+    readonly bgBlack: 40;
+    readonly bgRed: 41;
+    readonly bgGreen: 42;
+    readonly bgYellow: 43;
+    readonly bgBlue: 44;
+    readonly bgMagenta: 45;
+    readonly bgCyan: 46;
+    readonly bgWhite: 47;
+};
+export declare const MODIFIERS: {
+    readonly bold: 1;
+    readonly dim: 2;
+    readonly italic: 3;
+    readonly underline: 4;
+    readonly inverse: 7;
+    readonly hidden: 8;
+    readonly strikethrough: 9;
+};
+export type ColorName = keyof typeof COLORS;
+export type ModifierName = keyof typeof MODIFIERS;
+export declare class Styler {
+    /**
+     * Applies ANSI styles to a string.
+     */
+    static style(text: string, ...styles: (ColorName | ModifierName)[]): string;
+    /**
+     * Removes ANSI codes to calculate real string length.
+     */
+    static strip(text: string): string;
+    /**
+     * Checks if a character code point is 'wide' (takes 2 columns).
+     * Simplified lookup for CJK and Emoji.
+     */
+    private static isWide;
+    /**
+     * Returns the visual length of the string (ignoring ANSI codes).
+     * Handles CJK and Emojis as 2 columns.
+     */
+    static len(text: string): number;
+    /**
+     * Truncates a string to fit within a visual width.
+     * Returns the substring.
+     */
+    static truncate(text: string, maxWidth: number): string;
+    /**
+     * Advanced truncation that preserves ANSI state.
+     * Returns the truncated string and the active ANSI style at the cut point.
+     */
+    static truncateWithState(text: string, maxWidth: number): {
+        result: string;
+        remaining: string;
+        endStyle: string;
+    };
+}

package/dist/core/Styler.js

@@ -0,0 +1,157 @@
+"use strict";
+// ==========================================
+// CORE: ANSI & STYLING
+// ==========================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Styler = exports.MODIFIERS = exports.COLORS = void 0;
+const ESC = '\x1b[';
+const RESET = `${ESC}0m`;
+exports.COLORS = {
+    // Foreground
+    black: 30, red: 31, green: 32, yellow: 33, blue: 34, magenta: 35, cyan: 36, white: 37,
+    gray: 90, brightRed: 91, brightGreen: 92, brightYellow: 93, brightBlue: 94, brightMagenta: 95, brightCyan: 96, brightWhite: 97,
+    // Background
+    bgBlack: 40, bgRed: 41, bgGreen: 42, bgYellow: 43, bgBlue: 44, bgMagenta: 45, bgCyan: 46, bgWhite: 47
+};
+exports.MODIFIERS = {
+    bold: 1, dim: 2, italic: 3, underline: 4, inverse: 7, hidden: 8, strikethrough: 9
+};
+class Styler {
+    /**
+     * Applies ANSI styles to a string.
+     */
+    static style(text, ...styles) {
+        const codes = styles.map(s => {
+            if (s in exports.COLORS)
+                return exports.COLORS[s];
+            if (s in exports.MODIFIERS)
+                return exports.MODIFIERS[s];
+            return '';
+        }).filter(Boolean).join(';');
+        return `${ESC}${codes}m${text}${RESET}`;
+    }
+    /**
+     * Removes ANSI codes to calculate real string length.
+     */
+    static strip(text) {
+        return text.replace(/\x1b\[[0-9;]*m/g, '');
+    }
+    /**
+     * Checks if a character code point is 'wide' (takes 2 columns).
+     * Simplified lookup for CJK and Emoji.
+     */
+    static isWide(code) {
+        if (!code)
+            return false;
+        return (code >= 0x1100 && ((code <= 0x115f) || // Hangul Jamo
+            (code === 0x2329) || // Left-pointing Angle Bracket
+            (code === 0x232a) || // Right-pointing Angle Bracket
+            (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) || // CJK ... Yi
+            (code >= 0xac00 && code <= 0xd7a3) || // Hangul Syllables
+            (code >= 0xf900 && code <= 0xfaff) || // CJK Compatibility Ideographs
+            (code >= 0xfe10 && code <= 0xfe19) || // Vertical forms
+            (code >= 0xfe30 && code <= 0xfe6f) || // CJK Compatibility Forms
+            (code >= 0xff00 && code <= 0xff60) || // Fullwidth Forms
+            (code >= 0xffe0 && code <= 0xffe6) ||
+            (code >= 0x1f300 && code <= 0x1f64f) || // Misc Symbols and Pictographs
+            (code >= 0x1f900 && code <= 0x1f9ff) // Supplemental Symbols and Pictographs
+        ));
+    }
+    /**
+     * Returns the visual length of the string (ignoring ANSI codes).
+     * Handles CJK and Emojis as 2 columns.
+     */
+    static len(text) {
+        const stripped = this.strip(text);
+        let len = 0;
+        for (const char of stripped) {
+            len += this.isWide(char.codePointAt(0)) ? 2 : 1;
+        }
+        return len;
+    }
+    /**
+     * Truncates a string to fit within a visual width.
+     * Returns the substring.
+     */
+    static truncate(text, maxWidth) {
+        const { result } = this.truncateWithState(text, maxWidth);
+        return result;
+    }
+    /**
+     * Advanced truncation that preserves ANSI state.
+     * Returns the truncated string and the active ANSI style at the cut point.
+     */
+    static truncateWithState(text, maxWidth) {
+        let width = 0;
+        let result = "";
+        let currentStyle = ""; // Tracks active style
+        let remaining = "";
+        const parts = text.split(/(\x1b\[[0-9;]*m)/);
+        let finished = false;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            if (finished) {
+                remaining += part;
+                continue;
+            }
+            if (part.startsWith('\x1b[')) {
+                result += part;
+                // Track style state
+                if (part === '\x1b[0m' || part === '\x1b[m') {
+                    currentStyle = "";
+                }
+                else {
+                    // This is a naive stack approximation. 
+                    // Real ANSI handling might be more complex (accumulating vs replacing).
+                    // But usually in TUI we just append.
+                    currentStyle += part;
+                }
+            }
+            else {
+                for (let j = 0; j < part.length; j++) {
+                    // Iterate by code point to handle surrogate pairs correctly?
+                    // JS strings are UTF-16. 'char' loop iterates code units.
+                    // But we need code points for isWide.
+                    // For simplicity, let's assume iterator handles surrogate pairs if we use `for...of` on string?
+                    // Actually `for (const char of part)` iterates code points (unicode) in ES6.
+                    // But we need index `j` to match `part`.
+                    // We can't mix index loop and iterator easily.
+                    // Let's use iterator and rebuild buffer.
+                    // But wait, the outer loop IS an iterator.
+                    // Previous implementation used `for (const char of part)`.
+                    // Let's stick to that but we need to know when we stop to build `remaining`.
+                    // Actually, let's restart the inner loop logic to be safer.
+                    break;
+                }
+                // Better approach for inner text
+                let partIndex = 0;
+                for (const char of part) {
+                    const charWidth = this.isWide(char.codePointAt(0)) ? 2 : 1;
+                    if (width + charWidth > maxWidth) {
+                        // We hit the limit.
+                        // We need to stop here.
+                        // `remaining` starts from here.
+                        // `part` is the current text chunk.
+                        remaining += part.substring(partIndex); // Rest of this part
+                        finished = true;
+                        break;
+                    }
+                    width += charWidth;
+                    result += char;
+                    partIndex += char.length; // char.length might be 2 for emojis
+                }
+            }
+        }
+        // If we finished with an active style, we should probably RESET it in result?
+        // Or leave it open? Screen.write handles it per cell.
+        // But if we print `result` then newline, the style might leak?
+        // Generally `truncate` returns the string to be printed.
+        // Ideally we append RESET to result if style is active, and PREPEND style to remaining.
+        return {
+            result: result + (currentStyle ? '\x1b[0m' : ''),
+            remaining: (currentStyle ? currentStyle : '') + remaining,
+            endStyle: currentStyle
+        };
+    }
+}
+exports.Styler = Styler;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Voonex - A zero-dependency Terminal UI Library.
+ * Copyright (c) CodeTease
+ */
+export * from './core/Screen';
+export * from './core/Input';
+export * from './core/Styler';
+export * from './core/Cursor';
+export * from './core/Layout';
+export * from './core/Focus';
+export * from './core/Events';
+export * from './core/Component';
+export * from './components/Box';
+export * from './components/Menu';
+export * from './components/ProgressBar';
+export * from './components/Table';
+export * from './components/Tree';
+export * from './components/Popup';
+export * from './components/Button';
+export * from './components/Input';
+export * from './components/Textarea';
+export * from './components/Select';
+export * from './components/Checkbox';
+export * from './components/Radio';
+export * from './components/Tab';

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Voonex - A zero-dependency Terminal UI Library.
+ * Copyright (c) CodeTease
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core/Screen"), exports);
+__exportStar(require("./core/Input"), exports);
+__exportStar(require("./core/Styler"), exports);
+__exportStar(require("./core/Cursor"), exports);
+__exportStar(require("./core/Layout"), exports);
+__exportStar(require("./core/Focus"), exports);
+__exportStar(require("./core/Events"), exports);
+__exportStar(require("./core/Component"), exports);
+__exportStar(require("./components/Box"), exports);
+__exportStar(require("./components/Menu"), exports);
+__exportStar(require("./components/ProgressBar"), exports);
+__exportStar(require("./components/Table"), exports);
+__exportStar(require("./components/Tree"), exports);
+__exportStar(require("./components/Popup"), exports);
+__exportStar(require("./components/Button"), exports);
+__exportStar(require("./components/Input"), exports);
+__exportStar(require("./components/Textarea"), exports);
+__exportStar(require("./components/Select"), exports);
+__exportStar(require("./components/Checkbox"), exports);
+__exportStar(require("./components/Radio"), exports);
+__exportStar(require("./components/Tab"), exports);