treste 2.5.1 → 2.5.2

package/dist/std-native.js

@@ -37,12 +37,51 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StdModules = exports.StdIO = exports.StdProcess = exports.StdPath = exports.StdRegEx = exports.StdCrypto = exports.StdDate = exports.StdJSON = exports.StdFileSystem = exports.StdDatabase = exports.StdGUI = exports.StdAsync = exports.StdHTTP = void 0;
+exports.StdModules = exports.StdTest = exports.StdStyle = exports.StdDOM = exports.StdIO = exports.StdProcess = exports.StdPath = exports.StdRegEx = exports.StdCrypto = exports.StdDate = exports.StdJSON = exports.StdFileSystem = exports.StdDatabase = exports.StdGUI = exports.StdAsync = exports.StdHTTP = void 0;
 const http = __importStar(require("http"));
 const https = __importStar(require("https"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const url_1 = require("url");
+const crypto = __importStar(require("crypto"));
+const readline = __importStar(require("readline"));
+// Database drivers - lazy loading
+let Database;
+let mysql;
+let pg;
+function loadSQLite() {
+    if (!Database) {
+        try {
+            Database = require('better-sqlite3');
+        }
+        catch (e) {
+            // Silently fail - will throw error when used
+        }
+    }
+    return Database;
+}
+function loadMySQL() {
+    if (!mysql) {
+        try {
+            mysql = require('mysql2/promise');
+        }
+        catch (e) {
+            // Silently fail - will throw error when used
+        }
+    }
+    return mysql;
+}
+function loadPostgreSQL() {
+    if (!pg) {
+        try {
+            pg = require('pg');
+        }
+        catch (e) {
+            // Silently fail - will throw error when used
+        }
+    }
+    return pg;
+}
 /**
  * ========================================
  * HTTP Module - Cliente e Servidor HTTP
@@ -1365,68 +1404,380 @@ StdGUI._ipcHandlersRegistered = false;
  */
 class StdDatabase {
     /**
-     * Open Database
+     * Sanitiza query SQL substituindo ? pelos valores de forma segura (Prevent SQL Injection)
+     */
+    static sanitizeQuery(query, params) {
+        if (!params || params.length === 0) {
+            return query;
+        }
+        // Escapar valores para prevenir SQL Injection
+        const escapeValue = (value) => {
+            if (value === null || value === undefined) {
+                return 'NULL';
+            }
+            if (typeof value === 'number') {
+                return String(value);
+            }
+            if (typeof value === 'boolean') {
+                return value ? '1' : '0';
+            }
+            // String: escapar aspas simples e barras
+            const escaped = String(value)
+                .replace(/\\/g, '\\\\')
+                .replace(/'/g, "''")
+                .replace(/"/g, '""');
+            return `'${escaped}'`;
+        };
+        // Substituir cada ? pelo valor correspondente
+        let safeQuery = query;
+        let paramIndex = 0;
+        // Substituir ? pelos valores escapados
+        safeQuery = safeQuery.replace(/\?/g, () => {
+            if (paramIndex < params.length) {
+                const value = escapeValue(params[paramIndex]);
+                paramIndex++;
+                return value;
+            }
+            return '?'; // Se não houver parâmetro suficiente, manter ?
+        });
+        return safeQuery;
+    }
+    /**
+     * Detect database type from connection string or path
+     */
+    static detectDBType(connection) {
+        if (connection.startsWith('mysql://') || connection.startsWith('mysql2://')) {
+            return 'mysql';
+        }
+        if (connection.startsWith('postgresql://') || connection.startsWith('postgres://')) {
+            return 'postgresql';
+        }
+        if (connection.endsWith('.db') || connection.includes('/') || connection.includes('\\')) {
+            return 'sqlite';
+        }
+        return 'unknown';
+    }
+    /**
+     * Parse MySQL connection string
+     */
+    static parseMySQLConnection(connectionString) {
+        try {
+            const url = new url_1.URL(connectionString);
+            return {
+                host: url.hostname,
+                port: parseInt(url.port) || 3306,
+                user: url.username,
+                password: url.password,
+                database: url.pathname.substring(1),
+            };
+        }
+        catch (e) {
+            throw new Error(`Invalid MySQL connection string: ${connectionString}`);
+        }
+    }
+    /**
+     * Parse PostgreSQL connection string
      */
-    static openDB(dbPath) {
+    static parsePostgreSQLConnection(connectionString) {
+        try {
+            const url = new url_1.URL(connectionString);
+            return {
+                host: url.hostname,
+                port: parseInt(url.port) || 5432,
+                user: url.username,
+                password: url.password,
+                database: url.pathname.substring(1),
+                ssl: url.searchParams.get('ssl') === 'true',
+            };
+        }
+        catch (e) {
+            throw new Error(`Invalid PostgreSQL connection string: ${connectionString}`);
+        }
+    }
+    /**
+     * Open Database - Supports SQLite, MySQL, PostgreSQL
+     */
+    static openDB(connection) {
+        // If it's an object, treat as config
+        if (typeof connection === 'object' && connection !== null) {
+            if (connection.type === 'mysql' || connection.host && !connection.path) {
+                return this.openMySQL(connection);
+            }
+            if (connection.type === 'postgresql' || connection.type === 'postgres') {
+                return this.openPostgreSQL(connection);
+            }
+        }
+        // Detect type from connection string
+        const dbType = this.detectDBType(String(connection));
+        if (dbType === 'mysql') {
+            const config = this.parseMySQLConnection(String(connection));
+            return this.openMySQL(config);
+        }
+        if (dbType === 'postgresql') {
+            const config = this.parsePostgreSQLConnection(String(connection));
+            return this.openPostgreSQL(config);
+        }
+        // Default to SQLite
+        return this.openSQLite(String(connection));
+    }
+    /**
+     * Open SQLite Database (real implementation)
+     */
+    static openSQLite(dbPath) {
         if (this.dbConnections.has(dbPath)) {
             return this.dbConnections.get(dbPath);
         }
-        // For now, use file-based mock database
-        const db = {
-            path: dbPath,
-            execute: (query, params = []) => {
-                console.log(`[DB] Executing: ${query}`, params);
-                return { success: true };
-            },
-            query: (query, params = []) => {
-                console.log(`[DB] Querying: ${query}`, params);
-                return [];
-            },
-            transaction: (fn) => {
-                console.log('[DB] Transaction started');
-                fn();
-                console.log('[DB] Transaction committed');
-            },
-            close: () => {
-                console.log(`[DB] Closed: ${dbPath}`);
-                this.dbConnections.delete(dbPath);
-            },
-        };
-        this.dbConnections.set(dbPath, db);
-        return db;
+        const Database = loadSQLite();
+        if (!Database) {
+            throw new Error('better-sqlite3 is not installed. Install it with: npm install better-sqlite3');
+        }
+        try {
+            const db = new Database(dbPath);
+            const dbWrapper = {
+                path: dbPath,
+                _db: db,
+                execute: (query, params = []) => {
+                    try {
+                        const stmt = db.prepare(query);
+                        const result = stmt.run(...params);
+                        return {
+                            success: true,
+                            lastInsertRowid: result.lastInsertRowid,
+                            changes: result.changes
+                        };
+                    }
+                    catch (error) {
+                        throw new Error(`SQLite execute error: ${error.message}`);
+                    }
+                },
+                query: (query, params = []) => {
+                    try {
+                        const stmt = db.prepare(query);
+                        return stmt.all(...params);
+                    }
+                    catch (error) {
+                        throw new Error(`SQLite query error: ${error.message}`);
+                    }
+                },
+                transaction: (fn) => {
+                    try {
+                        const transaction = db.transaction(fn);
+                        transaction();
+                    }
+                    catch (error) {
+                        throw new Error(`SQLite transaction error: ${error.message}`);
+                    }
+                },
+                close: () => {
+                    try {
+                        db.close();
+                        this.dbConnections.delete(dbPath);
+                    }
+                    catch (error) {
+                        throw new Error(`SQLite close error: ${error.message}`);
+                    }
+                },
+            };
+            this.dbConnections.set(dbPath, dbWrapper);
+            return dbWrapper;
+        }
+        catch (error) {
+            throw new Error(`Failed to open SQLite database: ${error.message}`);
+        }
+    }
+    /**
+     * Open MySQL Database (real implementation)
+     */
+    static openMySQL(config) {
+        const connectionKey = `mysql://${config.host}:${config.port}/${config.database}`;
+        if (this.dbConnections.has(connectionKey)) {
+            return this.dbConnections.get(connectionKey);
+        }
+        const mysql = loadMySQL();
+        if (!mysql) {
+            throw new Error('mysql2 is not installed. Install it with: npm install mysql2');
+        }
+        try {
+            const pool = mysql.createPool({
+                host: config.host || 'localhost',
+                port: config.port || 3306,
+                user: config.user || 'root',
+                password: config.password || '',
+                database: config.database,
+                waitForConnections: true,
+                connectionLimit: 10,
+                queueLimit: 0,
+            });
+            const dbWrapper = {
+                _pool: pool,
+                _config: config,
+                execute: async (query, params = []) => {
+                    try {
+                        const [result] = await pool.execute(query, params);
+                        return {
+                            success: true,
+                            insertId: result.insertId,
+                            affectedRows: result.affectedRows
+                        };
+                    }
+                    catch (error) {
+                        throw new Error(`MySQL execute error: ${error.message}`);
+                    }
+                },
+                query: async (query, params = []) => {
+                    try {
+                        const [rows] = await pool.execute(query, params);
+                        return rows;
+                    }
+                    catch (error) {
+                        throw new Error(`MySQL query error: ${error.message}`);
+                    }
+                },
+                transaction: async (fn) => {
+                    const connection = await pool.getConnection();
+                    try {
+                        await connection.beginTransaction();
+                        await fn(connection);
+                        await connection.commit();
+                    }
+                    catch (error) {
+                        await connection.rollback();
+                        throw new Error(`MySQL transaction error: ${error.message}`);
+                    }
+                    finally {
+                        connection.release();
+                    }
+                },
+                close: async () => {
+                    try {
+                        await pool.end();
+                        this.dbConnections.delete(connectionKey);
+                    }
+                    catch (error) {
+                        throw new Error(`MySQL close error: ${error.message}`);
+                    }
+                },
+            };
+            this.dbConnections.set(connectionKey, dbWrapper);
+            return dbWrapper;
+        }
+        catch (error) {
+            throw new Error(`Failed to open MySQL database: ${error.message}`);
+        }
+    }
+    /**
+     * Open PostgreSQL Database (real implementation)
+     */
+    static openPostgreSQL(config) {
+        const connectionKey = `postgresql://${config.host}:${config.port}/${config.database}`;
+        if (this.dbConnections.has(connectionKey)) {
+            return this.dbConnections.get(connectionKey);
+        }
+        const pgLib = loadPostgreSQL();
+        if (!pgLib) {
+            throw new Error('pg is not installed. Install it with: npm install pg');
+        }
+        try {
+            const pool = new pgLib.Pool({
+                host: config.host || 'localhost',
+                port: config.port || 5432,
+                user: config.user || 'postgres',
+                password: config.password || '',
+                database: config.database,
+                max: 20,
+                idleTimeoutMillis: 30000,
+                connectionTimeoutMillis: 2000,
+                ssl: config.ssl || false,
+            });
+            const dbWrapper = {
+                _pool: pool,
+                _config: config,
+                execute: async (query, params = []) => {
+                    try {
+                        const result = await pool.query(query, params);
+                        return {
+                            success: true,
+                            rowCount: result.rowCount,
+                            rows: result.rows
+                        };
+                    }
+                    catch (error) {
+                        throw new Error(`PostgreSQL execute error: ${error.message}`);
+                    }
+                },
+                query: async (query, params = []) => {
+                    try {
+                        const result = await pool.query(query, params);
+                        return result.rows;
+                    }
+                    catch (error) {
+                        throw new Error(`PostgreSQL query error: ${error.message}`);
+                    }
+                },
+                transaction: async (fn) => {
+                    const client = await pool.connect();
+                    try {
+                        await client.query('BEGIN');
+                        await fn(client);
+                        await client.query('COMMIT');
+                    }
+                    catch (error) {
+                        await client.query('ROLLBACK');
+                        throw new Error(`PostgreSQL transaction error: ${error.message}`);
+                    }
+                    finally {
+                        client.release();
+                    }
+                },
+                close: async () => {
+                    try {
+                        await pool.end();
+                        this.dbConnections.delete(connectionKey);
+                    }
+                    catch (error) {
+                        throw new Error(`PostgreSQL close error: ${error.message}`);
+                    }
+                },
+            };
+            this.dbConnections.set(connectionKey, dbWrapper);
+            return dbWrapper;
+        }
+        catch (error) {
+            throw new Error(`Failed to open PostgreSQL database: ${error.message}`);
+        }
     }
     /**
      * Query Builder
      */
     static createQueryBuilder(table) {
         const builder = {
-            table,
+            table: table,
             selectFields: '*',
             whereClause: '',
             orderClause: '',
             limitValue: '',
             conditions: [],
-            select: function (fields) {
-                this.selectFields = fields;
-                return this;
-            },
-            where: function (condition) {
-                this.whereClause = `WHERE ${condition}`;
-                return this;
-            },
-            order: function (field) {
-                this.orderClause = `ORDER BY ${field}`;
-                return this;
-            },
-            limit: function (n) {
-                this.limitValue = `LIMIT ${n}`;
-                return this;
-            },
-            execute: function () {
-                const sql = `SELECT ${this.selectFields} FROM ${this.table} ${this.whereClause} ${this.orderClause} ${this.limitValue}`;
-                console.log(`[Query Builder] ${sql}`);
-                return [];
-            },
+        };
+        builder.select = function (fields) {
+            builder.selectFields = fields;
+            return builder;
+        };
+        builder.where = function (condition) {
+            builder.whereClause = `WHERE ${condition}`;
+            return builder;
+        };
+        builder.order = function (field) {
+            builder.orderClause = `ORDER BY ${field}`;
+            return builder;
+        };
+        builder.limit = function (n) {
+            builder.limitValue = `LIMIT ${n}`;
+            return builder;
+        };
+        builder.execute = function () {
+            const sql = `SELECT ${builder.selectFields} FROM ${builder.table} ${builder.whereClause} ${builder.orderClause} ${builder.limitValue}`;
+            console.log(`[Query Builder] ${sql}`);
+            return [];
         };
         return builder;
     }
@@ -1634,7 +1985,6 @@ exports.StdDate = StdDate;
  * Crypto Module
  * ========================================
  */
-const crypto = __importStar(require("crypto"));
 class StdCrypto {
     /**
      * Hash MD5
@@ -1876,7 +2226,6 @@ exports.StdProcess = StdProcess;
  * IO Module - Entrada e Saída
  * ========================================
  */
-const readline = __importStar(require("readline"));
 class StdIO {
     /**
      * Initialize readline interface if needed
@@ -1998,6 +2347,427 @@ class StdIO {
 }
 exports.StdIO = StdIO;
 StdIO.rl = null;
+/**
+ * ========================================
+ * DOM Module - Manipulação de DOM (Front-End)
+ * ========================================
+ */
+class StdDOM {
+    /**
+     * Verifica se está rodando no navegador
+     */
+    static isBrowser() {
+        return typeof globalThis.window !== 'undefined' && typeof globalThis.document !== 'undefined';
+    }
+    /**
+     * Selecionar elemento (querySelector)
+     */
+    static selecionar(seletor) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.selecionar só funciona no navegador. Use --mode web para compilar.');
+        }
+        return globalThis.document.querySelector(seletor);
+    }
+    static select(seletor) {
+        return this.selecionar(seletor);
+    }
+    /**
+     * Adicionar evento (addEventListener)
+     */
+    static evento(elemento, tipo, callback) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.evento só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (elemento && elemento.addEventListener) {
+            elemento.addEventListener(tipo, callback);
+        }
+    }
+    static addEvent(elemento, tipo, callback) {
+        this.evento(elemento, tipo, callback);
+    }
+    /**
+     * Manipular texto (innerText)
+     */
+    static texto(elemento, valor) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.texto só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (!elemento)
+            return '';
+        if (valor !== undefined) {
+            elemento.innerText = valor;
+        }
+        else {
+            return elemento.innerText || '';
+        }
+    }
+    static setText(elemento, valor) {
+        return this.texto(elemento, valor);
+    }
+    /**
+     * Manipular HTML (innerHTML)
+     */
+    static html(elemento, valor) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.html só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (!elemento)
+            return '';
+        if (valor !== undefined) {
+            elemento.innerHTML = valor;
+        }
+        else {
+            return elemento.innerHTML || '';
+        }
+    }
+    static setHTML(elemento, valor) {
+        return this.html(elemento, valor);
+    }
+    /**
+     * Obter/definir valor de input (value)
+     */
+    static valor(elemento, valor) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.valor só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (!elemento)
+            return null;
+        if (valor !== undefined) {
+            elemento.value = valor;
+        }
+        else {
+            return elemento.value !== undefined ? elemento.value : null;
+        }
+    }
+    static val(elemento, valor) {
+        return this.valor(elemento, valor);
+    }
+    /**
+     * Criar elemento (createElement)
+     */
+    static criar(tag) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.criar só funciona no navegador. Use --mode web para compilar.');
+        }
+        return globalThis.document.createElement(tag);
+    }
+    static create(tag) {
+        return this.criar(tag);
+    }
+    /**
+     * Adicionar elemento ao DOM (appendChild)
+     */
+    static adicionar(parent, child) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.adicionar só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (parent && parent.appendChild && child) {
+            parent.appendChild(child);
+        }
+    }
+    static append(parent, child) {
+        this.adicionar(parent, child);
+    }
+    /**
+     * Remover elemento (removeChild)
+     */
+    static remover(elemento) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.remover só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (elemento && elemento.parentNode) {
+            elemento.parentNode.removeChild(elemento);
+        }
+    }
+    static remove(elemento) {
+        this.remover(elemento);
+    }
+    /**
+     * Obter atributo (getAttribute)
+     */
+    static atributo(elemento, nome) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.atributo só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (!elemento || !elemento.getAttribute)
+            return null;
+        return elemento.getAttribute(nome);
+    }
+    static getAttr(elemento, nome) {
+        return this.atributo(elemento, nome);
+    }
+    /**
+     * Definir atributo (setAttribute)
+     */
+    static definirАтрибут(elemento, nome, valor) {
+        if (!this.isBrowser()) {
+            throw new Error('DOM.definirАтрибут só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (elemento && elemento.setAttribute) {
+            elemento.setAttribute(nome, valor);
+        }
+    }
+    static setAttr(elemento, nome, valor) {
+        this.definirАтрибут(elemento, nome, valor);
+    }
+}
+exports.StdDOM = StdDOM;
+/**
+ * ========================================
+ * Style Module - Gerenciamento de CSS
+ * ========================================
+ */
+class StdStyle {
+    /**
+     * Verifica se está rodando no navegador
+     */
+    static isBrowser() {
+        return typeof globalThis.window !== 'undefined' && typeof globalThis.document !== 'undefined';
+    }
+    /**
+     * Carregar CSS de CDN (Bootstrap, Tailwind, etc)
+     */
+    static carregarCDN(url) {
+        if (!this.isBrowser()) {
+            throw new Error('Style.carregarCDN só funciona no navegador. Use --mode web para compilar.');
+        }
+        const doc = globalThis.document;
+        const link = doc.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = url;
+        doc.head.appendChild(link);
+    }
+    static loadCDN(url) {
+        this.carregarCDN(url);
+    }
+    /**
+     * Carregar CSS de arquivo local
+     * No modo web, o compilador deve injetar o conteúdo do arquivo
+     */
+    static carregarАрхив(caminho) {
+        if (!this.isBrowser()) {
+            // No Node.js, apenas log (o compilador web deve injetar)
+            console.log(`[Style] Carregando CSS: ${caminho} (será injetado no bundle)`);
+            return;
+        }
+        // No navegador, criar link para o arquivo
+        const doc = globalThis.document;
+        const link = doc.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = caminho;
+        doc.head.appendChild(link);
+    }
+    static loadFile(caminho) {
+        this.carregarАрхив(caminho);
+    }
+    /**
+     * Aplicar estilos inline a um elemento
+     */
+    static aplicar(elemento, estilos) {
+        if (!this.isBrowser()) {
+            throw new Error('Style.aplicar só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (!elemento || !elemento.style)
+            return;
+        // Mapear propriedades em cirílico para CSS
+        const mapeamento = {
+            cor: 'color',
+            фон: 'backgroundColor',
+            фонЦвет: 'backgroundColor',
+            ширина: 'width',
+            высота: 'height',
+            отступ: 'padding',
+            маржа: 'margin',
+            граница: 'border',
+            размерШрифта: 'fontSize',
+            весШрифта: 'fontWeight',
+            выравнивание: 'textAlign',
+            отображение: 'display',
+        };
+        for (const key in estilos) {
+            const cssProp = mapeamento[key] || key;
+            elemento.style[cssProp] = estilos[key];
+        }
+    }
+    static apply(elemento, estilos) {
+        this.aplicar(elemento, estilos);
+    }
+    /**
+     * Obter estilo computado
+     */
+    static obter(elemento, propriedade) {
+        if (!this.isBrowser()) {
+            throw new Error('Style.obter só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (!elemento)
+            return null;
+        const win = globalThis.window;
+        const computed = win.getComputedStyle ? win.getComputedStyle(elemento) : null;
+        return computed ? computed[propriedade] : null;
+    }
+    static get(elemento, propriedade) {
+        return this.obter(elemento, propriedade);
+    }
+    /**
+     * Definir estilo individual
+     */
+    static definir(elemento, propriedade, valor) {
+        if (!this.isBrowser()) {
+            throw new Error('Style.definir só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (elemento && elemento.style) {
+            elemento.style[propriedade] = valor;
+        }
+    }
+    static set(elemento, propriedade, valor) {
+        this.definir(elemento, propriedade, valor);
+    }
+    /**
+     * Adicionar classe CSS
+     */
+    static добавитьКласс(elemento, classe) {
+        if (!this.isBrowser()) {
+            throw new Error('Style.добавитьКласс só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (elemento && elemento.classList) {
+            elemento.classList.add(classe);
+        }
+    }
+    static addClass(elemento, classe) {
+        this.добавитьКласс(elemento, classe);
+    }
+    /**
+     * Remover classe CSS
+     */
+    static удалитьКласс(elemento, classe) {
+        if (!this.isBrowser()) {
+            throw new Error('Style.удалитьКласс só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (elemento && elemento.classList) {
+            elemento.classList.remove(classe);
+        }
+    }
+    static removeClass(elemento, classe) {
+        this.удалитьКласс(elemento, classe);
+    }
+    /**
+     * Alternar classe CSS
+     */
+    static переключитьКласс(elemento, classe) {
+        if (!this.isBrowser()) {
+            throw new Error('Style.переключитьКласс só funciona no navegador. Use --mode web para compilar.');
+        }
+        if (elemento && elemento.classList) {
+            elemento.classList.toggle(classe);
+        }
+    }
+    static toggleClass(elemento, classe) {
+        this.переключитьКласс(elemento, classe);
+    }
+}
+exports.StdStyle = StdStyle;
+/**
+ * ========================================
+ * Test Module - Framework de Testes
+ * ========================================
+ */
+class StdTest {
+    /**
+     * Descrever um teste
+     */
+    static descrever(nome, callback) {
+        this.tests.push({ name: nome, fn: callback });
+    }
+    static describe(nome, callback) {
+        this.descrever(nome, callback);
+    }
+    /**
+     * Afirmar condição
+     */
+    static afirmar(condicao, mensagem = 'Assertion failed') {
+        if (!condicao) {
+            throw new Error(mensagem);
+        }
+    }
+    static assert(condicao, mensagem = 'Assertion failed') {
+        this.afirmar(condicao, mensagem);
+    }
+    /**
+     * Afirmar igualdade
+     */
+    static igual(esperado, atual, mensagem) {
+        if (esperado !== atual) {
+            const msg = mensagem || `Expected ${esperado}, but got ${atual}`;
+            throw new Error(msg);
+        }
+    }
+    static equal(esperado, atual, mensagem) {
+        this.igual(esperado, atual, mensagem);
+    }
+    /**
+     * Afirmar que é verdadeiro
+     */
+    static verdadeiro(valor, mensagem) {
+        if (valor !== true) {
+            const msg = mensagem || `Expected true, but got ${valor}`;
+            throw new Error(msg);
+        }
+    }
+    static isTrue(valor, mensagem) {
+        this.verdadeiro(valor, mensagem);
+    }
+    /**
+     * Afirmar que é falso
+     */
+    static ложь(valor, mensagem) {
+        if (valor !== false) {
+            const msg = mensagem || `Expected false, but got ${valor}`;
+            throw new Error(msg);
+        }
+    }
+    static isFalse(valor, mensagem) {
+        this.ложь(valor, mensagem);
+    }
+    /**
+     * Executar todos os testes
+     */
+    static выполнить() {
+        this.results = [];
+        let passed = 0;
+        let failed = 0;
+        for (const test of this.tests) {
+            try {
+                test.fn();
+                this.results.push({ name: test.name, passed: true });
+                passed++;
+                console.log(`✅ ${test.name}`);
+            }
+            catch (error) {
+                this.results.push({ name: test.name, passed: false, error: error.message });
+                failed++;
+                console.error(`❌ ${test.name}: ${error.message}`);
+            }
+        }
+        console.log(`\n📊 Testes: ${passed} passaram, ${failed} falharam`);
+        return { passed, failed, results: this.results };
+    }
+    static run() {
+        return this.выполнить();
+    }
+    /**
+     * Limpar testes registrados
+     */
+    static limpar() {
+        this.tests = [];
+        this.results = [];
+    }
+    static clear() {
+        this.limpar();
+    }
+}
+exports.StdTest = StdTest;
+StdTest.tests = [];
+StdTest.results = [];
 /**
  * Export all modules
  */
@@ -2014,5 +2784,8 @@ exports.StdModules = {
     Path: StdPath,
     Process: StdProcess,
     IO: StdIO,
+    DOM: StdDOM,
+    Style: StdStyle,
+    Test: StdTest,
 };
 //# sourceMappingURL=std-native.js.map