@sochdb/sochdb 0.4.0

package/dist/esm/sql-engine.js

@@ -0,0 +1,875 @@
+"use strict";
+/**
+ * SQL Engine for SochDB JavaScript SDK
+ *
+ * Provides SQL support on top of the KV storage backend.
+ * Tables are stored as:
+ *   - Schema: _sql/tables/{table_name}/schema -> JSON schema definition
+ *   - Rows: _sql/tables/{table_name}/rows/{row_id} -> JSON row data
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLExecutor = exports.SQLParser = void 0;
+// Copyright 2025 Sushanth (https://github.com/sushanthpy)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+const uuid_1 = require("uuid");
+/**
+ * Simple SQL parser for DDL and DML operations.
+ */
+class SQLParser {
+    /**
+     * Parse a SQL statement.
+     */
+    static parse(sql) {
+        sql = sql.trim();
+        const upper = sql.toUpperCase();
+        if (upper.startsWith('CREATE TABLE')) {
+            return SQLParser.parseCreateTable(sql);
+        }
+        else if (upper.startsWith('CREATE INDEX')) {
+            return SQLParser.parseCreateIndex(sql);
+        }
+        else if (upper.startsWith('DROP TABLE')) {
+            return SQLParser.parseDropTable(sql);
+        }
+        else if (upper.startsWith('DROP INDEX')) {
+            return SQLParser.parseDropIndex(sql);
+        }
+        else if (upper.startsWith('INSERT')) {
+            return SQLParser.parseInsert(sql);
+        }
+        else if (upper.startsWith('SELECT')) {
+            return SQLParser.parseSelect(sql);
+        }
+        else if (upper.startsWith('UPDATE')) {
+            return SQLParser.parseUpdate(sql);
+        }
+        else if (upper.startsWith('DELETE')) {
+            return SQLParser.parseDelete(sql);
+        }
+        else {
+            throw new Error(`Unsupported SQL statement: ${sql.substring(0, 50)}`);
+        }
+    }
+    static parseCreateTable(sql) {
+        const match = sql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s*\((.*)\)/is);
+        if (!match) {
+            throw new Error(`Invalid CREATE TABLE: ${sql}`);
+        }
+        const tableName = match[1];
+        const colsStr = match[2];
+        const columns = [];
+        let primaryKey;
+        const colDefs = SQLParser.splitColumns(colsStr);
+        for (const colDef of colDefs) {
+            const trimmed = colDef.trim();
+            if (!trimmed)
+                continue;
+            // Check for PRIMARY KEY constraint
+            if (trimmed.toUpperCase().startsWith('PRIMARY KEY')) {
+                const pkMatch = trimmed.match(/PRIMARY\s+KEY\s*\((\w+)\)/i);
+                if (pkMatch) {
+                    primaryKey = pkMatch[1];
+                }
+                continue;
+            }
+            // Parse column: name TYPE [PRIMARY KEY] [NOT NULL] [DEFAULT value]
+            const parts = trimmed.split(/\s+/);
+            if (parts.length < 2)
+                continue;
+            const colName = parts[0];
+            let colType = parts[1].toUpperCase();
+            // Normalize types
+            if (['INTEGER', 'INT', 'BIGINT', 'SMALLINT'].includes(colType)) {
+                colType = 'INT';
+            }
+            else if (['VARCHAR', 'CHAR', 'STRING', 'TEXT'].includes(colType)) {
+                colType = 'TEXT';
+            }
+            else if (['REAL', 'DOUBLE', 'FLOAT', 'DECIMAL', 'NUMERIC'].includes(colType)) {
+                colType = 'FLOAT';
+            }
+            else if (['BOOLEAN', 'BOOL'].includes(colType)) {
+                colType = 'BOOL';
+            }
+            else if (['BLOB', 'BYTES', 'BINARY'].includes(colType)) {
+                colType = 'BLOB';
+            }
+            const colUpper = trimmed.toUpperCase();
+            const isPk = colUpper.includes('PRIMARY KEY');
+            const nullable = !colUpper.includes('NOT NULL');
+            if (isPk) {
+                primaryKey = colName;
+            }
+            columns.push({
+                name: colName,
+                type: colType,
+                nullable,
+                primaryKey: isPk,
+            });
+        }
+        return {
+            operation: 'CREATE_TABLE',
+            data: { table: tableName, columns, primaryKey },
+        };
+    }
+    static splitColumns(colsStr) {
+        const result = [];
+        let current = '';
+        let depth = 0;
+        for (const char of colsStr) {
+            if (char === '(') {
+                depth++;
+                current += char;
+            }
+            else if (char === ')') {
+                depth--;
+                current += char;
+            }
+            else if (char === ',' && depth === 0) {
+                result.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim()) {
+            result.push(current);
+        }
+        return result;
+    }
+    static parseDropTable(sql) {
+        const match = sql.match(/DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(\w+)/i);
+        if (!match) {
+            throw new Error(`Invalid DROP TABLE: ${sql}`);
+        }
+        return { operation: 'DROP_TABLE', data: { table: match[1] } };
+    }
+    static parseCreateIndex(sql) {
+        // CREATE INDEX idx_name ON table_name(column_name)
+        const match = sql.match(/CREATE\s+INDEX\s+(\w+)\s+ON\s+(\w+)\s*\(\s*(\w+)\s*\)/i);
+        if (!match) {
+            throw new Error(`Invalid CREATE INDEX syntax: ${sql}`);
+        }
+        return {
+            operation: 'CREATE_INDEX',
+            data: {
+                indexName: match[1],
+                table: match[2],
+                column: match[3],
+            },
+        };
+    }
+    static parseDropIndex(sql) {
+        // DROP INDEX idx_name ON table_name
+        const match = sql.match(/DROP\s+INDEX\s+(\w+)\s+ON\s+(\w+)/i);
+        if (!match) {
+            throw new Error(`Invalid DROP INDEX syntax: ${sql}`);
+        }
+        return {
+            operation: 'DROP_INDEX',
+            data: {
+                indexName: match[1],
+                table: match[2],
+            },
+        };
+    }
+    static parseInsert(sql) {
+        // INSERT INTO table (col1, col2) VALUES (val1, val2)
+        let match = sql.match(/INSERT\s+INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\((.+)\)/is);
+        if (match) {
+            const table = match[1];
+            const columns = match[2].split(',').map((c) => c.trim());
+            const values = SQLParser.parseValues(match[3]);
+            return { operation: 'INSERT', data: { table, columns, values } };
+        }
+        // INSERT INTO table VALUES (val1, val2)
+        match = sql.match(/INSERT\s+INTO\s+(\w+)\s+VALUES\s*\((.+)\)/is);
+        if (match) {
+            const table = match[1];
+            const values = SQLParser.parseValues(match[2]);
+            return { operation: 'INSERT', data: { table, columns: null, values } };
+        }
+        throw new Error(`Invalid INSERT: ${sql}`);
+    }
+    static parseValues(valuesStr) {
+        const values = [];
+        let current = '';
+        let inString = false;
+        let stringChar = null;
+        for (const char of valuesStr) {
+            if ((char === '"' || char === "'") && !inString) {
+                inString = true;
+                stringChar = char;
+                current += char;
+            }
+            else if (char === stringChar && inString) {
+                inString = false;
+                stringChar = null;
+                current += char;
+            }
+            else if (char === ',' && !inString) {
+                values.push(SQLParser.parseValue(current.trim()));
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim()) {
+            values.push(SQLParser.parseValue(current.trim()));
+        }
+        return values;
+    }
+    static parseValue(valStr) {
+        if (!valStr || valStr.toUpperCase() === 'NULL') {
+            return null;
+        }
+        // String literals
+        if ((valStr.startsWith("'") && valStr.endsWith("'")) ||
+            (valStr.startsWith('"') && valStr.endsWith('"'))) {
+            return valStr.slice(1, -1);
+        }
+        // Boolean
+        if (valStr.toUpperCase() === 'TRUE')
+            return true;
+        if (valStr.toUpperCase() === 'FALSE')
+            return false;
+        // Numbers
+        if (valStr.includes('.')) {
+            const num = parseFloat(valStr);
+            if (!isNaN(num))
+                return num;
+        }
+        const intVal = parseInt(valStr, 10);
+        if (!isNaN(intVal))
+            return intVal;
+        return valStr;
+    }
+    static parseSelect(sql) {
+        // Extract table name first
+        const tableMatch = sql.match(/FROM\s+(\w+)/i);
+        if (!tableMatch) {
+            throw new Error(`Invalid SELECT: ${sql}`);
+        }
+        const table = tableMatch[1];
+        // Extract columns
+        const colsMatch = sql.match(/SELECT\s+(.+?)\s+FROM/is);
+        let columns = ['*'];
+        if (colsMatch) {
+            const colsStr = colsMatch[1].trim();
+            columns = colsStr === '*' ? ['*'] : colsStr.split(',').map((c) => c.trim());
+        }
+        // Extract WHERE clause
+        let conditions = [];
+        const whereMatch = sql.match(/WHERE\s+(.+?)(?:\s+ORDER|\s+LIMIT|\s+OFFSET|$)/is);
+        if (whereMatch) {
+            conditions = SQLParser.parseWhere(whereMatch[1]);
+        }
+        // Extract ORDER BY
+        let orderBy = [];
+        const orderMatch = sql.match(/ORDER\s+BY\s+(.+?)(?:\s+LIMIT|\s+OFFSET|$)/i);
+        if (orderMatch) {
+            for (const part of orderMatch[1].split(',')) {
+                const trimmed = part.trim();
+                if (trimmed.toUpperCase().endsWith(' DESC')) {
+                    orderBy.push([trimmed.slice(0, -5).trim(), 'DESC']);
+                }
+                else if (trimmed.toUpperCase().endsWith(' ASC')) {
+                    orderBy.push([trimmed.slice(0, -4).trim(), 'ASC']);
+                }
+                else {
+                    orderBy.push([trimmed, 'ASC']);
+                }
+            }
+        }
+        // Extract LIMIT
+        let limit;
+        const limitMatch = sql.match(/LIMIT\s+(\d+)/i);
+        if (limitMatch) {
+            limit = parseInt(limitMatch[1], 10);
+        }
+        // Extract OFFSET
+        let offset;
+        const offsetMatch = sql.match(/OFFSET\s+(\d+)/i);
+        if (offsetMatch) {
+            offset = parseInt(offsetMatch[1], 10);
+        }
+        return {
+            operation: 'SELECT',
+            data: { table, columns, where: conditions, orderBy, limit, offset },
+        };
+    }
+    static parseWhere(whereClause) {
+        const conditions = [];
+        const parts = whereClause.split(/\s+AND\s+/i);
+        for (const part of parts) {
+            const match = part.match(/(\w+)\s*(=|!=|<>|>=|<=|>|<|LIKE|NOT\s+LIKE)\s*(.+)/i);
+            if (match) {
+                const col = match[1];
+                let op = match[2].toUpperCase().replace(/\s+/g, '_');
+                if (op === '<>')
+                    op = '!=';
+                const val = SQLParser.parseValue(match[3].trim());
+                conditions.push([col, op, val]);
+            }
+        }
+        return conditions;
+    }
+    static parseUpdate(sql) {
+        const match = sql.match(/UPDATE\s+(\w+)\s+SET\s+(.+?)(?:\s+WHERE\s+(.+))?$/is);
+        if (!match) {
+            throw new Error(`Invalid UPDATE: ${sql}`);
+        }
+        const table = match[1];
+        const setClause = match[2];
+        const whereClause = match[3];
+        // Parse SET clause
+        const updates = {};
+        for (const part of setClause.split(',')) {
+            const eqMatch = part.match(/\s*(\w+)\s*=\s*(.+)\s*/);
+            if (eqMatch) {
+                updates[eqMatch[1]] = SQLParser.parseValue(eqMatch[2].trim());
+            }
+        }
+        let conditions = [];
+        if (whereClause) {
+            conditions = SQLParser.parseWhere(whereClause);
+        }
+        return { operation: 'UPDATE', data: { table, updates, where: conditions } };
+    }
+    static parseDelete(sql) {
+        const match = sql.match(/DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/is);
+        if (!match) {
+            throw new Error(`Invalid DELETE: ${sql}`);
+        }
+        const table = match[1];
+        let conditions = [];
+        if (match[2]) {
+            conditions = SQLParser.parseWhere(match[2]);
+        }
+        return { operation: 'DELETE', data: { table, where: conditions } };
+    }
+}
+exports.SQLParser = SQLParser;
+/**
+ * SQL Executor that operates on a KV database.
+ */
+class SQLExecutor {
+    db;
+    // Key prefixes for SQL data
+    TABLE_PREFIX = '_sql/tables/';
+    SCHEMA_SUFFIX = '/schema';
+    ROWS_PREFIX = '/rows/';
+    INDEX_PREFIX = '/indexes/';
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Execute a SQL statement.
+     */
+    async execute(sql) {
+        const { operation, data } = SQLParser.parse(sql);
+        switch (operation) {
+            case 'CREATE_TABLE':
+                return this.createTable(data);
+            case 'DROP_TABLE':
+                return this.dropTable(data);
+            case 'CREATE_INDEX':
+                return this.createIndex(data);
+            case 'DROP_INDEX':
+                return this.dropIndex(data);
+            case 'INSERT':
+                return this.insert(data);
+            case 'SELECT':
+                return this.select(data);
+            case 'UPDATE':
+                return this.update(data);
+            case 'DELETE':
+                return this.deleteRows(data);
+            default:
+                throw new Error(`Unknown operation: ${operation}`);
+        }
+    }
+    schemaKey(table) {
+        return this.TABLE_PREFIX + table + this.SCHEMA_SUFFIX;
+    }
+    rowKey(table, rowId) {
+        return this.TABLE_PREFIX + table + this.ROWS_PREFIX + rowId;
+    }
+    rowPrefix(table) {
+        return this.TABLE_PREFIX + table + this.ROWS_PREFIX;
+    }
+    indexMetaKey(table, indexName) {
+        return this.TABLE_PREFIX + table + this.INDEX_PREFIX + indexName + '/meta';
+    }
+    indexPrefix(table, indexName) {
+        return this.TABLE_PREFIX + table + this.INDEX_PREFIX + indexName + '/';
+    }
+    indexKey(table, indexName, columnValue, rowId) {
+        return this.TABLE_PREFIX + table + this.INDEX_PREFIX + indexName + '/' + columnValue + '/' + rowId;
+    }
+    indexValuePrefix(table, indexName, columnValue) {
+        return this.TABLE_PREFIX + table + this.INDEX_PREFIX + indexName + '/' + columnValue + '/';
+    }
+    async getSchema(table) {
+        const data = await this.db.get(this.schemaKey(table));
+        if (!data)
+            return null;
+        return JSON.parse(data.toString());
+    }
+    async getIndexes(table) {
+        // Returns map of index_name -> column_name
+        const indexes = {};
+        const prefix = this.TABLE_PREFIX + table + this.INDEX_PREFIX;
+        const pairs = await this.db.scan(prefix);
+        for (const { key, value } of pairs) {
+            const keyStr = key.toString();
+            if (keyStr.endsWith('/meta')) {
+                const info = JSON.parse(value.toString());
+                const parts = keyStr.split('/');
+                if (parts.length >= 5) {
+                    const indexName = parts[parts.length - 2];
+                    indexes[indexName] = info.column;
+                }
+            }
+        }
+        return indexes;
+    }
+    async hasIndexForColumn(table, column) {
+        const indexes = await this.getIndexes(table);
+        for (const [indexName, indexCol] of Object.entries(indexes)) {
+            if (indexCol === column) {
+                return { has: true, name: indexName };
+            }
+        }
+        return { has: false, name: '' };
+    }
+    async lookupByIndex(table, indexName, value) {
+        const prefix = this.indexValuePrefix(table, indexName, value);
+        const pairs = await this.db.scan(prefix);
+        return pairs.map(p => p.value.toString());
+    }
+    async updateIndex(table, indexName, column, oldRow, newRow, rowId) {
+        const oldVal = oldRow[column];
+        const newVal = newRow[column];
+        if (oldVal === newVal) {
+            return;
+        }
+        // Remove old index entry
+        if (oldVal != null) {
+            const oldKey = this.indexKey(table, indexName, String(oldVal), rowId);
+            await this.db.delete(oldKey);
+        }
+        // Add new index entry
+        if (newVal != null) {
+            const newKey = this.indexKey(table, indexName, String(newVal), rowId);
+            await this.db.put(newKey, rowId);
+        }
+    }
+    findIndexedEqualityCondition(table, conditions, indexes) {
+        for (const [col, op, val] of conditions) {
+            if (op === '=' && Object.values(indexes).includes(col)) {
+                return [col, val];
+            }
+        }
+        return null;
+    }
+    async createTable(data) {
+        const table = data.table;
+        const columns = data.columns;
+        const primaryKey = data.primaryKey;
+        // Check if table exists
+        if (await this.getSchema(table)) {
+            throw new Error(`Table '${table}' already exists`);
+        }
+        const schema = { name: table, columns, primaryKey };
+        await this.db.put(this.schemaKey(table), JSON.stringify(schema));
+        return { rows: [], columns: [], rowsAffected: 0 };
+    }
+    async dropTable(data) {
+        const table = data.table;
+        // Delete all indexes first
+        const indexes = await this.getIndexes(table);
+        for (const indexName of Object.keys(indexes)) {
+            const idxPrefix = this.indexPrefix(table, indexName);
+            const idxPairs = await this.db.scan(idxPrefix);
+            for (const { key } of idxPairs) {
+                await this.db.delete(key);
+            }
+            await this.db.delete(this.indexMetaKey(table, indexName));
+        }
+        // Delete all rows
+        const prefix = this.rowPrefix(table);
+        const rows = await this.db.scan(prefix);
+        let rowsDeleted = 0;
+        for (const { key } of rows) {
+            await this.db.delete(key);
+            rowsDeleted++;
+        }
+        // Delete schema
+        await this.db.delete(this.schemaKey(table));
+        return { rows: [], columns: [], rowsAffected: rowsDeleted };
+    }
+    async createIndex(data) {
+        const indexName = data.indexName;
+        const table = data.table;
+        const column = data.column;
+        const schema = await this.getSchema(table);
+        if (!schema) {
+            throw new Error(`Table '${table}' does not exist`);
+        }
+        // Check column exists
+        if (!schema.columns.some(c => c.name === column)) {
+            throw new Error(`Column '${column}' does not exist in table '${table}'`);
+        }
+        // Check index doesn't already exist
+        const metaKey = this.indexMetaKey(table, indexName);
+        const existing = await this.db.get(metaKey);
+        if (existing) {
+            throw new Error(`Index '${indexName}' already exists on table '${table}'`);
+        }
+        // Store index metadata
+        const meta = { column, table };
+        await this.db.put(metaKey, JSON.stringify(meta));
+        // Build index from existing rows
+        const prefix = this.rowPrefix(table);
+        const pairs = await this.db.scan(prefix);
+        let indexedCount = 0;
+        for (const { value } of pairs) {
+            const row = JSON.parse(value.toString());
+            const rowId = row['_id'];
+            const colValue = row[column];
+            if (colValue != null) {
+                const idxKey = this.indexKey(table, indexName, String(colValue), rowId);
+                await this.db.put(idxKey, rowId);
+                indexedCount++;
+            }
+        }
+        return { rows: [], columns: [], rowsAffected: indexedCount };
+    }
+    async dropIndex(data) {
+        const indexName = data.indexName;
+        const table = data.table;
+        // Delete all index entries
+        const idxPrefix = this.indexPrefix(table, indexName);
+        const pairs = await this.db.scan(idxPrefix);
+        let deleted = 0;
+        for (const { key } of pairs) {
+            await this.db.delete(key);
+            deleted++;
+        }
+        // Delete index metadata
+        await this.db.delete(this.indexMetaKey(table, indexName));
+        return { rows: [], columns: [], rowsAffected: deleted };
+    }
+    async insert(data) {
+        const table = data.table;
+        let columns = data.columns;
+        const values = data.values;
+        const schema = await this.getSchema(table);
+        if (!schema) {
+            throw new Error(`Table '${table}' does not exist`);
+        }
+        // If no columns specified, use schema order
+        if (!columns) {
+            columns = schema.columns.map((c) => c.name);
+        }
+        if (columns.length !== values.length) {
+            throw new Error(`Column count (${columns.length}) doesn't match value count (${values.length})`);
+        }
+        // Create row object
+        const row = {};
+        for (let i = 0; i < columns.length; i++) {
+            row[columns[i]] = values[i];
+        }
+        // Generate row ID
+        let rowId;
+        if (schema.primaryKey && schema.primaryKey in row) {
+            rowId = String(row[schema.primaryKey]);
+        }
+        else {
+            rowId = (0, uuid_1.v4)();
+        }
+        row['_id'] = rowId;
+        await this.db.put(this.rowKey(table, rowId), JSON.stringify(row));
+        // Maintain indexes
+        const indexes = await this.getIndexes(table);
+        for (const [indexName, indexCol] of Object.entries(indexes)) {
+            if (row[indexCol] != null) {
+                const idxKey = this.indexKey(table, indexName, String(row[indexCol]), rowId);
+                await this.db.put(idxKey, rowId);
+            }
+        }
+        return { rows: [], columns: [], rowsAffected: 1 };
+    }
+    async select(data) {
+        const table = data.table;
+        let columns = data.columns;
+        const conditions = data.where;
+        const orderBy = data.orderBy;
+        const limit = data.limit;
+        const offset = data.offset;
+        const schema = await this.getSchema(table);
+        if (!schema) {
+            throw new Error(`Table '${table}' does not exist`);
+        }
+        // Get column names
+        if (columns.length === 1 && columns[0] === '*') {
+            columns = schema.columns.map((c) => c.name);
+        }
+        // Scan all rows
+        const prefix = this.rowPrefix(table);
+        const scanResults = await this.db.scan(prefix);
+        let rows = [];
+        for (const { value } of scanResults) {
+            const row = JSON.parse(value.toString());
+            // Apply WHERE conditions
+            if (this.matchesConditions(row, conditions)) {
+                // Project columns
+                const projected = {};
+                for (const col of columns) {
+                    if (col in row) {
+                        projected[col] = row[col];
+                    }
+                }
+                rows.push(projected);
+            }
+        }
+        // Apply ORDER BY
+        if (orderBy && orderBy.length > 0) {
+            rows.sort((a, b) => {
+                for (const [col, direction] of orderBy) {
+                    const aVal = a[col];
+                    const bVal = b[col];
+                    // Handle nulls
+                    if (aVal === null || aVal === undefined)
+                        return 1;
+                    if (bVal === null || bVal === undefined)
+                        return -1;
+                    let cmp = 0;
+                    if (aVal < bVal)
+                        cmp = -1;
+                    else if (aVal > bVal)
+                        cmp = 1;
+                    if (direction === 'DESC')
+                        cmp = -cmp;
+                    if (cmp !== 0)
+                        return cmp;
+                }
+                return 0;
+            });
+        }
+        // Apply OFFSET and LIMIT
+        if (offset && offset > 0) {
+            rows = rows.slice(offset);
+        }
+        if (limit !== undefined && limit > 0) {
+            rows = rows.slice(0, limit);
+        }
+        return { rows, columns, rowsAffected: 0 };
+    }
+    matchesConditions(row, conditions) {
+        for (const [col, op, val] of conditions) {
+            const rowVal = row[col];
+            switch (op) {
+                case '=':
+                    if (rowVal !== val)
+                        return false;
+                    break;
+                case '!=':
+                    if (rowVal === val)
+                        return false;
+                    break;
+                case '>':
+                    if (rowVal === null || rowVal === undefined || rowVal <= val)
+                        return false;
+                    break;
+                case '>=':
+                    if (rowVal === null || rowVal === undefined || rowVal < val)
+                        return false;
+                    break;
+                case '<':
+                    if (rowVal === null || rowVal === undefined || rowVal >= val)
+                        return false;
+                    break;
+                case '<=':
+                    if (rowVal === null || rowVal === undefined || rowVal > val)
+                        return false;
+                    break;
+                case 'LIKE': {
+                    if (rowVal === null || rowVal === undefined)
+                        return false;
+                    const pattern = String(val).replace(/%/g, '.*').replace(/_/g, '.');
+                    if (!new RegExp(`^${pattern}$`, 'i').test(String(rowVal)))
+                        return false;
+                    break;
+                }
+                case 'NOT_LIKE': {
+                    if (rowVal === null || rowVal === undefined)
+                        return true;
+                    const pattern = String(val).replace(/%/g, '.*').replace(/_/g, '.');
+                    if (new RegExp(`^${pattern}$`, 'i').test(String(rowVal)))
+                        return false;
+                    break;
+                }
+            }
+        }
+        return true;
+    }
+    async update(data) {
+        const table = data.table;
+        const updates = data.updates;
+        const conditions = data.where;
+        const schema = await this.getSchema(table);
+        if (!schema) {
+            throw new Error(`Table '${table}' does not exist`);
+        }
+        const indexes = await this.getIndexes(table);
+        let rowsAffected = 0;
+        // Try index-accelerated path
+        const indexedCond = this.findIndexedEqualityCondition(table, conditions, indexes);
+        if (indexedCond) {
+            // Index-accelerated UPDATE
+            const [col, val] = indexedCond;
+            const indexResult = await this.hasIndexForColumn(table, col);
+            if (indexResult.has) {
+                const rowIds = await this.lookupByIndex(table, indexResult.name, String(val));
+                for (const rowId of rowIds) {
+                    const key = this.rowKey(table, rowId);
+                    const value = await this.db.get(key);
+                    if (!value)
+                        continue;
+                    const oldRow = JSON.parse(value.toString());
+                    // Apply all WHERE conditions (not just the indexed one)
+                    if (!this.matchesConditions(oldRow, conditions)) {
+                        continue;
+                    }
+                    // Apply updates
+                    const newRow = { ...oldRow };
+                    for (const [ucol, uval] of Object.entries(updates)) {
+                        newRow[ucol] = uval;
+                    }
+                    // Update indexes for changed columns
+                    for (const [idxName, idxCol] of Object.entries(indexes)) {
+                        if (idxCol in updates) {
+                            await this.updateIndex(table, idxName, idxCol, oldRow, newRow, rowId);
+                        }
+                    }
+                    await this.db.put(key, JSON.stringify(newRow));
+                    rowsAffected++;
+                }
+            }
+        }
+        else {
+            // Fallback: full table scan
+            const prefix = this.rowPrefix(table);
+            const scanResults = await this.db.scan(prefix);
+            for (const { key, value } of scanResults) {
+                const oldRow = JSON.parse(value.toString());
+                // Apply WHERE conditions
+                if (this.matchesConditions(oldRow, conditions)) {
+                    // Apply updates
+                    const newRow = { ...oldRow };
+                    for (const [col, val] of Object.entries(updates)) {
+                        newRow[col] = val;
+                    }
+                    const rowId = oldRow['_id'];
+                    // Update indexes for changed columns
+                    for (const [idxName, idxCol] of Object.entries(indexes)) {
+                        if (idxCol in updates) {
+                            await this.updateIndex(table, idxName, idxCol, oldRow, newRow, rowId);
+                        }
+                    }
+                    await this.db.put(key, JSON.stringify(newRow));
+                    rowsAffected++;
+                }
+            }
+        }
+        return { rows: [], columns: [], rowsAffected };
+    }
+    async deleteRows(data) {
+        const table = data.table;
+        const conditions = data.where;
+        const schema = await this.getSchema(table);
+        if (!schema) {
+            throw new Error(`Table '${table}' does not exist`);
+        }
+        const indexes = await this.getIndexes(table);
+        let rowsAffected = 0;
+        // Try index-accelerated path
+        const indexedCond = this.findIndexedEqualityCondition(table, conditions, indexes);
+        if (indexedCond) {
+            // Index-accelerated DELETE
+            const [col, val] = indexedCond;
+            const indexResult = await this.hasIndexForColumn(table, col);
+            if (indexResult.has) {
+                const rowIds = await this.lookupByIndex(table, indexResult.name, String(val));
+                const keysToDelete = [];
+                const rowsToDelete = [];
+                for (const rowId of rowIds) {
+                    const key = this.rowKey(table, rowId);
+                    const value = await this.db.get(key);
+                    if (!value)
+                        continue;
+                    const row = JSON.parse(value.toString());
+                    // Apply all WHERE conditions (not just the indexed one)
+                    if (this.matchesConditions(row, conditions)) {
+                        keysToDelete.push(Buffer.from(key));
+                        rowsToDelete.push({ row, rowId });
+                    }
+                }
+                // Delete rows and update indexes
+                for (let i = 0; i < keysToDelete.length; i++) {
+                    const key = keysToDelete[i];
+                    const { row, rowId } = rowsToDelete[i];
+                    // Remove from all indexes
+                    for (const [idxName, idxCol] of Object.entries(indexes)) {
+                        const emptyRow = {};
+                        await this.updateIndex(table, idxName, idxCol, row, emptyRow, rowId);
+                    }
+                    await this.db.delete(key);
+                    rowsAffected++;
+                }
+            }
+        }
+        else {
+            // Fallback: full table scan
+            const prefix = this.rowPrefix(table);
+            const scanResults = await this.db.scan(prefix);
+            const keysToDelete = [];
+            const rowsToDelete = [];
+            for (const { key, value } of scanResults) {
+                const row = JSON.parse(value.toString());
+                // Apply WHERE conditions
+                if (this.matchesConditions(row, conditions)) {
+                    const rowId = row['_id'];
+                    keysToDelete.push(key);
+                    rowsToDelete.push({ row, rowId });
+                }
+            }
+            // Delete collected rows and update indexes
+            for (let i = 0; i < keysToDelete.length; i++) {
+                const key = keysToDelete[i];
+                const { row, rowId } = rowsToDelete[i];
+                // Remove from all indexes
+                for (const [idxName, idxCol] of Object.entries(indexes)) {
+                    const emptyRow = {};
+                    await this.updateIndex(table, idxName, idxCol, row, emptyRow, rowId);
+                }
+                await this.db.delete(key);
+                rowsAffected++;
+            }
+        }
+        return { rows: [], columns: [], rowsAffected };
+    }
+}
+exports.SQLExecutor = SQLExecutor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sql-engine.js","sourceRoot":"","sources":["../../src/sql-engine.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAEH,0DAA0D;AAC1D,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AAEjD,+BAAoC;AAkDpC;;GAEG;AACH,MAAa,SAAS;IACpB;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,GAAW;QACtB,GAAG,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;QACjB,MAAM,KAAK,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;QAEhC,IAAI,KAAK,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;YACrC,OAAO,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACzC,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;YAC5C,OAAO,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACzC,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YAC1C,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACvC,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YAC1C,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACvC,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtC,OAAO,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtC,OAAO,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtC,OAAO,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtC,OAAO,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,8BAA8B,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,GAAW;QACzC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CACrB,8DAA8D,CAC/D,CAAC;QACF,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,EAAE,CAAC,CAAC;QAClD,CAAC;QAED,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3B,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACzB,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,IAAI,UAA8B,CAAC;QAEnC,MAAM,OAAO,GAAG,SAAS,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAEhD,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,OAAO;gBAAE,SAAS;YAEvB,mCAAmC;YACnC,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC;gBACpD,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;gBAC5D,IAAI,OAAO,EAAE,CAAC;oBACZ,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC1B,CAAC;gBACD,SAAS;YACX,CAAC;YAED,mEAAmE;YACnE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACnC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;gBAAE,SAAS;YAE/B,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;YAErC,kBAAkB;YAClB,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC/D,OAAO,GAAG,KAAK,CAAC;YAClB,CAAC;iBAAM,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBACnE,OAAO,GAAG,MAAM,CAAC;YACnB,CAAC;iBAAM,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC/E,OAAO,GAAG,OAAO,CAAC;YACpB,CAAC;iBAAM,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBACjD,OAAO,GAAG,MAAM,CAAC;YACnB,CAAC;iBAAM,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzD,OAAO,GAAG,MAAM,CAAC;YACnB,CAAC;YAED,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;YACvC,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;YAC9C,MAAM,QAAQ,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;YAEhD,IAAI,IAAI,EAAE,CAAC;gBACT,UAAU,GAAG,OAAO,CAAC;YACvB,CAAC;YAED,OAAO,CAAC,IAAI,CAAC;gBACX,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,OAAO;gBACb,QAAQ;gBACR,UAAU,EAAE,IAAI;aACjB,CAAC,CAAC;QACL,CAAC;QAED,OAAO;YACL,SAAS,EAAE,cAAc;YACzB,IAAI,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE;SAChD,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,YAAY,CAAC,OAAe;QACzC,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;YAC3B,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBACjB,KAAK,EAAE,CAAC;gBACR,OAAO,IAAI,IAAI,CAAC;YAClB,CAAC;iBAAM,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBACxB,KAAK,EAAE,CAAC;gBACR,OAAO,IAAI,IAAI,CAAC;YAClB,CAAC;iBAAM,IAAI,IAAI,KAAK,GAAG,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;gBACvC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACrB,OAAO,GAAG,EAAE,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,OAAO,IAAI,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAED,IAAI,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,MAAM,CAAC,cAAc,CAAC,GAAW;QACvC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAC;QACpE,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,uBAAuB,GAAG,EAAE,CAAC,CAAC;QAChD,CAAC;QACD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IAChE,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,GAAW;QACzC,mDAAmD;QACnD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAClF,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,gCAAgC,GAAG,EAAE,CAAC,CAAC;QACzD,CAAC;QACD,OAAO;YACL,SAAS,EAAE,cAAc;YACzB,IAAI,EAAE;gBACJ,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;gBACnB,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;gBACf,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;aACjB;SACF,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,cAAc,CAAC,GAAW;QACvC,oCAAoC;QACpC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;QAC9D,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,8BAA8B,GAAG,EAAE,CAAC,CAAC;QACvD,CAAC;QACD,OAAO;YACL,SAAS,EAAE,YAAY;YACvB,IAAI,EAAE;gBACJ,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;gBACnB,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;aAChB;SACF,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,GAAW;QACpC,qDAAqD;QACrD,IAAI,KAAK,GAAG,GAAG,CAAC,KAAK,CACnB,2DAA2D,CAC5D,CAAC;QAEF,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACvB,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACzD,MAAM,MAAM,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;QACnE,CAAC;QAED,wCAAwC;QACxC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACvB,MAAM,MAAM,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;QACzE,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,mBAAmB,GAAG,EAAE,CAAC,CAAC;IAC5C,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,SAAiB;QAC1C,MAAM,MAAM,GAAU,EAAE,CAAC;QACzB,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,UAAU,GAAkB,IAAI,CAAC;QAErC,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChD,QAAQ,GAAG,IAAI,CAAC;gBAChB,UAAU,GAAG,IAAI,CAAC;gBAClB,OAAO,IAAI,IAAI,CAAC;YAClB,CAAC;iBAAM,IAAI,IAAI,KAAK,UAAU,IAAI,QAAQ,EAAE,CAAC;gBAC3C,QAAQ,GAAG,KAAK,CAAC;gBACjB,UAAU,GAAG,IAAI,CAAC;gBAClB,OAAO,IAAI,IAAI,CAAC;YAClB,CAAC;iBAAM,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACrC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;gBAClD,OAAO,GAAG,EAAE,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,OAAO,IAAI,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAED,IAAI,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QACpD,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,MAAM,CAAC,UAAU,CAAC,MAAc;QACtC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;YAC/C,OAAO,IAAI,CAAC;QACd,CAAC;QAED,kBAAkB;QAClB,IACE,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAChD,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAChD,CAAC;YACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC7B,CAAC;QAED,UAAU;QACV,IAAI,MAAM,CAAC,WAAW,EAAE,KAAK,MAAM;YAAE,OAAO,IAAI,CAAC;QACjD,IAAI,MAAM,CAAC,WAAW,EAAE,KAAK,OAAO;YAAE,OAAO,KAAK,CAAC;QAEnD,UAAU;QACV,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,MAAM,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;YAC/B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;gBAAE,OAAO,GAAG,CAAC;QAC9B,CAAC;QACD,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;YAAE,OAAO,MAAM,CAAC;QAElC,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,GAAW;QACpC,2BAA2B;QAC3B,MAAM,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QAC9C,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,mBAAmB,GAAG,EAAE,CAAC,CAAC;QAC5C,CAAC;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAE5B,kBAAkB;QAClB,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,yBAAyB,CAAC,CAAC;QACvD,IAAI,OAAO,GAAa,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YACpC,OAAO,GAAG,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC9E,CAAC;QAED,uBAAuB;QACvB,IAAI,UAAU,GAAiC,EAAE,CAAC;QAClD,MAAM,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACjF,IAAI,UAAU,EAAE,CAAC;YACf,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QACnD,CAAC;QAED,mBAAmB;QACnB,IAAI,OAAO,GAA4B,EAAE,CAAC;QAC1C,MAAM,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC,6CAA6C,CAAC,CAAC;QAC5E,IAAI,UAAU,EAAE,CAAC;YACf,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;gBAC5B,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;oBAC5C,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;gBACtD,CAAC;qBAAM,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;oBAClD,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;gBACrD,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;gBACjC,CAAC;YACH,CAAC;QACH,CAAC;QAED,gBAAgB;QAChB,IAAI,KAAyB,CAAC;QAC9B,MAAM,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAC/C,IAAI,UAAU,EAAE,CAAC;YACf,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACtC,CAAC;QAED,iBAAiB;QACjB,IAAI,MAA0B,CAAC;QAC/B,MAAM,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACjD,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACxC,CAAC;QAED,OAAO;YACL,SAAS,EAAE,QAAQ;YACnB,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE;SACpE,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,UAAU,CAAC,WAAmB;QAC3C,MAAM,UAAU,GAAiC,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAE9C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAC;YAChF,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;gBACrB,IAAI,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;gBACrD,IAAI,EAAE,KAAK,IAAI;oBAAE,EAAE,GAAG,IAAI,CAAC;gBAC3B,MAAM,GAAG,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;gBAClD,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,GAAW;QACpC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAC;QAC/E,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,mBAAmB,GAAG,EAAE,CAAC,CAAC;QAC5C,CAAC;QAED,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACvB,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3B,MAAM,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAE7B,mBAAmB;QACnB,MAAM,OAAO,GAAwB,EAAE,CAAC;QACxC,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YACxC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;YACrD,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAChE,CAAC;QACH,CAAC;QAED,IAAI,UAAU,GAAiC,EAAE,CAAC;QAClD,IAAI,WAAW,EAAE,CAAC;YAChB,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,CAAC;IAC9E,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,GAAW;QACpC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,8CAA8C,CAAC,CAAC;QACxE,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,mBAAmB,GAAG,EAAE,CAAC,CAAC;QAC5C,CAAC;QAED,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACvB,IAAI,UAAU,GAAiC,EAAE,CAAC;QAClD,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YACb,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9C,CAAC;QAED,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,CAAC;IACrE,CAAC;CACF;AA7WD,8BA6WC;AAYD;;GAEG;AACH,MAAa,WAAW;IACd,EAAE,CAAoB;IAE9B,4BAA4B;IACX,YAAY,GAAG,cAAc,CAAC;IAC9B,aAAa,GAAG,SAAS,CAAC;IAC1B,WAAW,GAAG,QAAQ,CAAC;IACvB,YAAY,GAAG,WAAW,CAAC;IAE5C,YAAY,EAAqB;QAC/B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,GAAW;QACvB,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAEjD,QAAQ,SAAS,EAAE,CAAC;YAClB,KAAK,cAAc;gBACjB,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAChC,KAAK,YAAY;gBACf,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC9B,KAAK,cAAc;gBACjB,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAChC,KAAK,YAAY;gBACf,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC9B,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3B,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3B,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3B,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAC/B;gBACE,MAAM,IAAI,KAAK,CAAC,sBAAsB,SAAS,EAAE,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAEO,SAAS,CAAC,KAAa;QAC7B,OAAO,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC;IACxD,CAAC;IAEO,MAAM,CAAC,KAAa,EAAE,KAAa;QACzC,OAAO,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC9D,CAAC;IAEO,SAAS,CAAC,KAAa;QAC7B,OAAO,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC;IACtD,CAAC;IAEO,YAAY,CAAC,KAAa,EAAE,SAAiB;QACnD,OAAO,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC;IAC7E,CAAC;IAEO,WAAW,CAAC,KAAa,EAAE,SAAiB;QAClD,OAAO,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,GAAG,CAAC;IACzE,CAAC;IAEO,QAAQ,CAAC,KAAa,EAAE,SAAiB,EAAE,WAAmB,EAAE,KAAa;QACnF,OAAO,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,GAAG,GAAG,WAAW,GAAG,GAAG,GAAG,KAAK,CAAC;IACrG,CAAC;IAEO,gBAAgB,CAAC,KAAa,EAAE,SAAiB,EAAE,WAAmB;QAC5E,OAAO,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,GAAG,GAAG,WAAW,GAAG,GAAG,CAAC;IAC7F,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,KAAa;QACnC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;IACrC,CAAC;IAEO,KAAK,CAAC,UAAU,CAAC,KAAa;QACpC,2CAA2C;QAC3C,MAAM,OAAO,GAA2B,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;QAC7D,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEzC,KAAK,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,KAAK,EAAE,CAAC;YACnC,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC7B,MAAM,IAAI,GAAc,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACrD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAChC,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;oBACtB,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBAC1C,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;gBACnC,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAAC,KAAa,EAAE,MAAc;QAC3D,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7C,KAAK,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5D,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;gBACxB,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;YACxC,CAAC;QACH,CAAC;QACD,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAClC,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,SAAiB,EAAE,KAAa;QACzE,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QAC9D,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACzC,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC5C,CAAC;IAEO,KAAK,CAAC,WAAW,CACvB,KAAa,EACb,SAAiB,EACjB,MAAc,EACd,MAA2B,EAC3B,MAA2B,EAC3B,KAAa;QAEb,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAC9B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAE9B,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QAED,yBAAyB;QACzB,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;YACnB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;YACtE,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC/B,CAAC;QAED,sBAAsB;QACtB,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;YACnB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;YACtE,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAEO,4BAA4B,CAClC,KAAa,EACb,UAAwC,EACxC,OAA+B;QAE/B,KAAK,MAAM,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,UAAU,EAAE,CAAC;YACxC,IAAI,EAAE,KAAK,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACvD,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,KAAK,CAAC,WAAW,CAAC,IAAyB;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAmB,CAAC;QACzC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QAEnC,wBAAwB;QACxB,IAAI,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,kBAAkB,CAAC,CAAC;QACrD,CAAC;QAED,MAAM,MAAM,GAAgB,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;QACjE,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAEjE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IACpD,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,IAAyB;QAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAEzB,2BAA2B;QAC3B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7C,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YACrD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC/C,KAAK,MAAM,EAAE,GAAG,EAAE,IAAI,QAAQ,EAAE,CAAC;gBAC/B,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC5B,CAAC;YACD,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC;QAC5D,CAAC;QAED,kBAAkB;QAClB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,WAAW,GAAG,CAAC,CAAC;QAEpB,KAAK,MAAM,EAAE,GAAG,EAAE,IAAI,IAAI,EAAE,CAAC;YAC3B,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,WAAW,EAAE,CAAC;QAChB,CAAC;QAED,gBAAgB;QAChB,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QAE5C,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC;IAC9D,CAAC;IAEO,KAAK,CAAC,WAAW,CAAC,IAAyB;QACjD,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAE3B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,kBAAkB,CAAC,CAAC;QACrD,CAAC;QAED,sBAAsB;QACtB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,WAAW,MAAM,8BAA8B,KAAK,GAAG,CAAC,CAAC;QAC3E,CAAC;QAED,oCAAoC;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QACpD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,UAAU,SAAS,8BAA8B,KAAK,GAAG,CAAC,CAAC;QAC7E,CAAC;QAED,uBAAuB;QACvB,MAAM,IAAI,GAAc,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;QAC1C,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAEjD,iCAAiC;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACzC,IAAI,YAAY,GAAG,CAAC,CAAC;QAErB,KAAK,MAAM,EAAE,KAAK,EAAE,IAAI,KAAK,EAAE,CAAC;YAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YACzC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;YACzB,MAAM,QAAQ,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;YAE7B,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;gBACrB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC;gBACxE,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;gBACjC,YAAY,EAAE,CAAC;YACjB,CAAC;QACH,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;IAC/D,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,IAAyB;QAC/C,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAEzB,2BAA2B;QAC3B,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QACrD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC5C,IAAI,OAAO,GAAG,CAAC,CAAC;QAEhB,KAAK,MAAM,EAAE,GAAG,EAAE,IAAI,KAAK,EAAE,CAAC;YAC5B,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,wBAAwB;QACxB,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC;QAE1D,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC;IAC1D,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,IAAyB;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAI,OAAO,GAAG,IAAI,CAAC,OAA0B,CAAC;QAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAe,CAAC;QAEpC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,kBAAkB,CAAC,CAAC;QACrD,CAAC;QAED,4CAA4C;QAC5C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC9C,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CACb,iBAAiB,OAAO,CAAC,MAAM,gCAAgC,MAAM,CAAC,MAAM,GAAG,CAChF,CAAC;QACJ,CAAC;QAED,oBAAoB;QACpB,MAAM,GAAG,GAAwB,EAAE,CAAC;QACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC9B,CAAC;QAED,kBAAkB;QAClB,IAAI,KAAa,CAAC;QAClB,IAAI,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,UAAU,IAAI,GAAG,EAAE,CAAC;YAClD,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;QACzC,CAAC;aAAM,CAAC;YACN,KAAK,GAAG,IAAA,SAAM,GAAE,CAAC;QACnB,CAAC;QACD,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;QAEnB,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;QAElE,mBAAmB;QACnB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7C,KAAK,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5D,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC;gBAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;gBAC7E,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YACnC,CAAC;QACH,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IACpD,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,IAAyB;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAI,OAAO,GAAG,IAAI,CAAC,OAAmB,CAAC;QACvC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAqC,CAAC;QAC9D,MAAM,OAAO,GAAG,IAAI,CAAC,OAAkC,CAAC;QACxD,MAAM,KAAK,GAAG,IAAI,CAAC,KAA2B,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,MAA4B,CAAC;QAEjD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,kBAAkB,CAAC,CAAC;QACrD,CAAC;QAED,mBAAmB;QACnB,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YAC/C,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC9C,CAAC;QAED,gBAAgB;QAChB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC/C,IAAI,IAAI,GAA+B,EAAE,CAAC;QAE1C,KAAK,MAAM,EAAE,KAAK,EAAE,IAAI,WAAW,EAAE,CAAC;YACpC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YAEzC,yBAAyB;YACzB,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,CAAC;gBAC5C,kBAAkB;gBAClB,MAAM,SAAS,GAAwB,EAAE,CAAC;gBAC1C,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;oBAC1B,IAAI,GAAG,IAAI,GAAG,EAAE,CAAC;wBACf,SAAS,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;oBAC5B,CAAC;gBACH,CAAC;gBACD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;QAED,iBAAiB;QACjB,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;gBACjB,KAAK,MAAM,CAAC,GAAG,EAAE,SAAS,CAAC,IAAI,OAAO,EAAE,CAAC;oBACvC,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;oBACpB,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;oBAEpB,eAAe;oBACf,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS;wBAAE,OAAO,CAAC,CAAC;oBAClD,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS;wBAAE,OAAO,CAAC,CAAC,CAAC;oBAEnD,IAAI,GAAG,GAAG,CAAC,CAAC;oBACZ,IAAI,IAAI,GAAG,IAAI;wBAAE,GAAG,GAAG,CAAC,CAAC,CAAC;yBACrB,IAAI,IAAI,GAAG,IAAI;wBAAE,GAAG,GAAG,CAAC,CAAC;oBAE9B,IAAI,SAAS,KAAK,MAAM;wBAAE,GAAG,GAAG,CAAC,GAAG,CAAC;oBACrC,IAAI,GAAG,KAAK,CAAC;wBAAE,OAAO,GAAG,CAAC;gBAC5B,CAAC;gBACD,OAAO,CAAC,CAAC;YACX,CAAC,CAAC,CAAC;QACL,CAAC;QAED,yBAAyB;QACzB,IAAI,MAAM,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;YACzB,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACrC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC9B,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IAC5C,CAAC;IAEO,iBAAiB,CACvB,GAAwB,EACxB,UAAwC;QAExC,KAAK,MAAM,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,UAAU,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;YAExB,QAAQ,EAAE,EAAE,CAAC;gBACX,KAAK,GAAG;oBACN,IAAI,MAAM,KAAK,GAAG;wBAAE,OAAO,KAAK,CAAC;oBACjC,MAAM;gBACR,KAAK,IAAI;oBACP,IAAI,MAAM,KAAK,GAAG;wBAAE,OAAO,KAAK,CAAC;oBACjC,MAAM;gBACR,KAAK,GAAG;oBACN,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,IAAI,GAAG;wBAAE,OAAO,KAAK,CAAC;oBAC3E,MAAM;gBACR,KAAK,IAAI;oBACP,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,GAAG,GAAG;wBAAE,OAAO,KAAK,CAAC;oBAC1E,MAAM;gBACR,KAAK,GAAG;oBACN,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,IAAI,GAAG;wBAAE,OAAO,KAAK,CAAC;oBAC3E,MAAM;gBACR,KAAK,IAAI;oBACP,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,GAAG,GAAG;wBAAE,OAAO,KAAK,CAAC;oBAC1E,MAAM;gBACR,KAAK,MAAM,CAAC,CAAC,CAAC;oBACZ,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS;wBAAE,OAAO,KAAK,CAAC;oBAC1D,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;oBACnE,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,OAAO,GAAG,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;wBAAE,OAAO,KAAK,CAAC;oBACxE,MAAM;gBACR,CAAC;gBACD,KAAK,UAAU,CAAC,CAAC,CAAC;oBAChB,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS;wBAAE,OAAO,IAAI,CAAC;oBACzD,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;oBACnE,IAAI,IAAI,MAAM,CAAC,IAAI,OAAO,GAAG,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;wBAAE,OAAO,KAAK,CAAC;oBACvE,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,IAAyB;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,OAA8B,CAAC;QACpD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAqC,CAAC;QAE9D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,kBAAkB,CAAC,CAAC;QACrD,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7C,IAAI,YAAY,GAAG,CAAC,CAAC;QAErB,6BAA6B;QAC7B,MAAM,WAAW,GAAG,IAAI,CAAC,4BAA4B,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAElF,IAAI,WAAW,EAAE,CAAC;YAChB,2BAA2B;YAC3B,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,WAAW,CAAC;YAC/B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAE7D,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC;gBACpB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;gBAE9E,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;oBAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;oBACtC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBACrC,IAAI,CAAC,KAAK;wBAAE,SAAS;oBAErB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAE5C,wDAAwD;oBACxD,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,CAAC;wBAChD,SAAS;oBACX,CAAC;oBAED,gBAAgB;oBAChB,MAAM,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC;oBAC7B,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;wBACnD,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;oBACtB,CAAC;oBAED,qCAAqC;oBACrC,KAAK,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;wBACxD,IAAI,MAAM,IAAI,OAAO,EAAE,CAAC;4BACtB,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;wBACxE,CAAC;oBACH,CAAC;oBAED,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;oBAC/C,YAAY,EAAE,CAAC;gBACjB,CAAC;YACH,CAAC;QACH,CAAC;aAAM,CAAC;YACN,4BAA4B;YAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACrC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAE/C,KAAK,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,WAAW,EAAE,CAAC;gBACzC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAE5C,yBAAyB;gBACzB,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,CAAC;oBAC/C,gBAAgB;oBAChB,MAAM,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC;oBAC7B,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;wBACjD,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;oBACpB,CAAC;oBAED,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;oBAE5B,qCAAqC;oBACrC,KAAK,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;wBACxD,IAAI,MAAM,IAAI,OAAO,EAAE,CAAC;4BACtB,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;wBACxE,CAAC;oBACH,CAAC;oBAED,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;oBAC/C,YAAY,EAAE,CAAC;gBACjB,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;IACjD,CAAC;IAEO,KAAK,CAAC,UAAU,CAAC,IAAyB;QAChD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,MAAM,UAAU,GAAG,IAAI,CAAC,KAAqC,CAAC;QAE9D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,kBAAkB,CAAC,CAAC;QACrD,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7C,IAAI,YAAY,GAAG,CAAC,CAAC;QAErB,6BAA6B;QAC7B,MAAM,WAAW,GAAG,IAAI,CAAC,4BAA4B,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAElF,IAAI,WAAW,EAAE,CAAC;YAChB,2BAA2B;YAC3B,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,WAAW,CAAC;YAC/B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAE7D,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC;gBACpB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC9E,MAAM,YAAY,GAAa,EAAE,CAAC;gBAClC,MAAM,YAAY,GAAuD,EAAE,CAAC;gBAE5E,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;oBAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;oBACtC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBACrC,IAAI,CAAC,KAAK;wBAAE,SAAS;oBAErB,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAEzC,wDAAwD;oBACxD,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,CAAC;wBAC5C,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;wBACpC,YAAY,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;oBACpC,CAAC;gBACH,CAAC;gBAED,iCAAiC;gBACjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC7C,MAAM,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;oBAC5B,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;oBAEvC,0BAA0B;oBAC1B,KAAK,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;wBACxD,MAAM,QAAQ,GAAwB,EAAE,CAAC;wBACzC,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;oBACvE,CAAC;oBAED,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;oBAC1B,YAAY,EAAE,CAAC;gBACjB,CAAC;YACH,CAAC;QACH,CAAC;aAAM,CAAC;YACN,4BAA4B;YAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACrC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC/C,MAAM,YAAY,GAAa,EAAE,CAAC;YAClC,MAAM,YAAY,GAAuD,EAAE,CAAC;YAE5E,KAAK,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,WAAW,EAAE,CAAC;gBACzC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAEzC,yBAAyB;gBACzB,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,CAAC;oBAC5C,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;oBACzB,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACvB,YAAY,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC;YAED,2CAA2C;YAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC7C,MAAM,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;gBAC5B,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;gBAEvC,0BAA0B;gBAC1B,KAAK,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;oBACxD,MAAM,QAAQ,GAAwB,EAAE,CAAC;oBACzC,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;gBACvE,CAAC;gBAED,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC1B,YAAY,EAAE,CAAC;YACjB,CAAC;QACH,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;IACjD,CAAC;CACF;AA/lBD,kCA+lBC","sourcesContent":["/**\n * SQL Engine for SochDB JavaScript SDK\n *\n * Provides SQL support on top of the KV storage backend.\n * Tables are stored as:\n *   - Schema: _sql/tables/{table_name}/schema -> JSON schema definition\n *   - Rows: _sql/tables/{table_name}/rows/{row_id} -> JSON row data\n *\n * @packageDocumentation\n */\n\n// Copyright 2025 Sushanth (https://github.com/sushanthpy)\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//     http://www.apache.org/licenses/LICENSE-2.0\n\nimport { v4 as uuidv4 } from 'uuid';\n\n/**\n * Result of a SQL query execution.\n */\nexport interface SQLQueryResult {\n  /** Result rows */\n  rows: Array<Record<string, any>>;\n  /** Column names */\n  columns: string[];\n  /** Number of rows affected (for INSERT/UPDATE/DELETE) */\n  rowsAffected: number;\n}\n\n/**\n * Column definition for a table.\n */\ninterface Column {\n  name: string;\n  type: string; // INT, TEXT, FLOAT, BOOL, BLOB\n  nullable: boolean;\n  primaryKey: boolean;\n  default?: any;\n}\n\n/**\n * Table schema definition.\n */\ninterface TableSchema {\n  name: string;\n  columns: Column[];\n  primaryKey?: string;\n}\n\n/**\n * Index metadata.\n */\ninterface IndexInfo {\n  column: string;\n  table: string;\n}\n\n/**\n * Parsed SQL operation result.\n */\ntype ParsedSQL = {\n  operation: string;\n  data: Record<string, any>;\n};\n\n/**\n * Simple SQL parser for DDL and DML operations.\n */\nexport class SQLParser {\n  /**\n   * Parse a SQL statement.\n   */\n  static parse(sql: string): ParsedSQL {\n    sql = sql.trim();\n    const upper = sql.toUpperCase();\n\n    if (upper.startsWith('CREATE TABLE')) {\n      return SQLParser.parseCreateTable(sql);\n    } else if (upper.startsWith('CREATE INDEX')) {\n      return SQLParser.parseCreateIndex(sql);\n    } else if (upper.startsWith('DROP TABLE')) {\n      return SQLParser.parseDropTable(sql);\n    } else if (upper.startsWith('DROP INDEX')) {\n      return SQLParser.parseDropIndex(sql);\n    } else if (upper.startsWith('INSERT')) {\n      return SQLParser.parseInsert(sql);\n    } else if (upper.startsWith('SELECT')) {\n      return SQLParser.parseSelect(sql);\n    } else if (upper.startsWith('UPDATE')) {\n      return SQLParser.parseUpdate(sql);\n    } else if (upper.startsWith('DELETE')) {\n      return SQLParser.parseDelete(sql);\n    } else {\n      throw new Error(`Unsupported SQL statement: ${sql.substring(0, 50)}`);\n    }\n  }\n\n  private static parseCreateTable(sql: string): ParsedSQL {\n    const match = sql.match(\n      /CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(\\w+)\\s*\\((.*)\\)/is\n    );\n    if (!match) {\n      throw new Error(`Invalid CREATE TABLE: ${sql}`);\n    }\n\n    const tableName = match[1];\n    const colsStr = match[2];\n    const columns: Column[] = [];\n    let primaryKey: string | undefined;\n\n    const colDefs = SQLParser.splitColumns(colsStr);\n\n    for (const colDef of colDefs) {\n      const trimmed = colDef.trim();\n      if (!trimmed) continue;\n\n      // Check for PRIMARY KEY constraint\n      if (trimmed.toUpperCase().startsWith('PRIMARY KEY')) {\n        const pkMatch = trimmed.match(/PRIMARY\\s+KEY\\s*\\((\\w+)\\)/i);\n        if (pkMatch) {\n          primaryKey = pkMatch[1];\n        }\n        continue;\n      }\n\n      // Parse column: name TYPE [PRIMARY KEY] [NOT NULL] [DEFAULT value]\n      const parts = trimmed.split(/\\s+/);\n      if (parts.length < 2) continue;\n\n      const colName = parts[0];\n      let colType = parts[1].toUpperCase();\n\n      // Normalize types\n      if (['INTEGER', 'INT', 'BIGINT', 'SMALLINT'].includes(colType)) {\n        colType = 'INT';\n      } else if (['VARCHAR', 'CHAR', 'STRING', 'TEXT'].includes(colType)) {\n        colType = 'TEXT';\n      } else if (['REAL', 'DOUBLE', 'FLOAT', 'DECIMAL', 'NUMERIC'].includes(colType)) {\n        colType = 'FLOAT';\n      } else if (['BOOLEAN', 'BOOL'].includes(colType)) {\n        colType = 'BOOL';\n      } else if (['BLOB', 'BYTES', 'BINARY'].includes(colType)) {\n        colType = 'BLOB';\n      }\n\n      const colUpper = trimmed.toUpperCase();\n      const isPk = colUpper.includes('PRIMARY KEY');\n      const nullable = !colUpper.includes('NOT NULL');\n\n      if (isPk) {\n        primaryKey = colName;\n      }\n\n      columns.push({\n        name: colName,\n        type: colType,\n        nullable,\n        primaryKey: isPk,\n      });\n    }\n\n    return {\n      operation: 'CREATE_TABLE',\n      data: { table: tableName, columns, primaryKey },\n    };\n  }\n\n  private static splitColumns(colsStr: string): string[] {\n    const result: string[] = [];\n    let current = '';\n    let depth = 0;\n\n    for (const char of colsStr) {\n      if (char === '(') {\n        depth++;\n        current += char;\n      } else if (char === ')') {\n        depth--;\n        current += char;\n      } else if (char === ',' && depth === 0) {\n        result.push(current);\n        current = '';\n      } else {\n        current += char;\n      }\n    }\n\n    if (current.trim()) {\n      result.push(current);\n    }\n\n    return result;\n  }\n\n  private static parseDropTable(sql: string): ParsedSQL {\n    const match = sql.match(/DROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?(\\w+)/i);\n    if (!match) {\n      throw new Error(`Invalid DROP TABLE: ${sql}`);\n    }\n    return { operation: 'DROP_TABLE', data: { table: match[1] } };\n  }\n\n  private static parseCreateIndex(sql: string): ParsedSQL {\n    // CREATE INDEX idx_name ON table_name(column_name)\n    const match = sql.match(/CREATE\\s+INDEX\\s+(\\w+)\\s+ON\\s+(\\w+)\\s*\\(\\s*(\\w+)\\s*\\)/i);\n    if (!match) {\n      throw new Error(`Invalid CREATE INDEX syntax: ${sql}`);\n    }\n    return {\n      operation: 'CREATE_INDEX',\n      data: {\n        indexName: match[1],\n        table: match[2],\n        column: match[3],\n      },\n    };\n  }\n\n  private static parseDropIndex(sql: string): ParsedSQL {\n    // DROP INDEX idx_name ON table_name\n    const match = sql.match(/DROP\\s+INDEX\\s+(\\w+)\\s+ON\\s+(\\w+)/i);\n    if (!match) {\n      throw new Error(`Invalid DROP INDEX syntax: ${sql}`);\n    }\n    return {\n      operation: 'DROP_INDEX',\n      data: {\n        indexName: match[1],\n        table: match[2],\n      },\n    };\n  }\n\n  private static parseInsert(sql: string): ParsedSQL {\n    // INSERT INTO table (col1, col2) VALUES (val1, val2)\n    let match = sql.match(\n      /INSERT\\s+INTO\\s+(\\w+)\\s*\\(([^)]+)\\)\\s*VALUES\\s*\\((.+)\\)/is\n    );\n\n    if (match) {\n      const table = match[1];\n      const columns = match[2].split(',').map((c) => c.trim());\n      const values = SQLParser.parseValues(match[3]);\n      return { operation: 'INSERT', data: { table, columns, values } };\n    }\n\n    // INSERT INTO table VALUES (val1, val2)\n    match = sql.match(/INSERT\\s+INTO\\s+(\\w+)\\s+VALUES\\s*\\((.+)\\)/is);\n    if (match) {\n      const table = match[1];\n      const values = SQLParser.parseValues(match[2]);\n      return { operation: 'INSERT', data: { table, columns: null, values } };\n    }\n\n    throw new Error(`Invalid INSERT: ${sql}`);\n  }\n\n  private static parseValues(valuesStr: string): any[] {\n    const values: any[] = [];\n    let current = '';\n    let inString = false;\n    let stringChar: string | null = null;\n\n    for (const char of valuesStr) {\n      if ((char === '\"' || char === \"'\") && !inString) {\n        inString = true;\n        stringChar = char;\n        current += char;\n      } else if (char === stringChar && inString) {\n        inString = false;\n        stringChar = null;\n        current += char;\n      } else if (char === ',' && !inString) {\n        values.push(SQLParser.parseValue(current.trim()));\n        current = '';\n      } else {\n        current += char;\n      }\n    }\n\n    if (current.trim()) {\n      values.push(SQLParser.parseValue(current.trim()));\n    }\n\n    return values;\n  }\n\n  private static parseValue(valStr: string): any {\n    if (!valStr || valStr.toUpperCase() === 'NULL') {\n      return null;\n    }\n\n    // String literals\n    if (\n      (valStr.startsWith(\"'\") && valStr.endsWith(\"'\")) ||\n      (valStr.startsWith('\"') && valStr.endsWith('\"'))\n    ) {\n      return valStr.slice(1, -1);\n    }\n\n    // Boolean\n    if (valStr.toUpperCase() === 'TRUE') return true;\n    if (valStr.toUpperCase() === 'FALSE') return false;\n\n    // Numbers\n    if (valStr.includes('.')) {\n      const num = parseFloat(valStr);\n      if (!isNaN(num)) return num;\n    }\n    const intVal = parseInt(valStr, 10);\n    if (!isNaN(intVal)) return intVal;\n\n    return valStr;\n  }\n\n  private static parseSelect(sql: string): ParsedSQL {\n    // Extract table name first\n    const tableMatch = sql.match(/FROM\\s+(\\w+)/i);\n    if (!tableMatch) {\n      throw new Error(`Invalid SELECT: ${sql}`);\n    }\n    const table = tableMatch[1];\n\n    // Extract columns\n    const colsMatch = sql.match(/SELECT\\s+(.+?)\\s+FROM/is);\n    let columns: string[] = ['*'];\n    if (colsMatch) {\n      const colsStr = colsMatch[1].trim();\n      columns = colsStr === '*' ? ['*'] : colsStr.split(',').map((c) => c.trim());\n    }\n\n    // Extract WHERE clause\n    let conditions: Array<[string, string, any]> = [];\n    const whereMatch = sql.match(/WHERE\\s+(.+?)(?:\\s+ORDER|\\s+LIMIT|\\s+OFFSET|$)/is);\n    if (whereMatch) {\n      conditions = SQLParser.parseWhere(whereMatch[1]);\n    }\n\n    // Extract ORDER BY\n    let orderBy: Array<[string, string]> = [];\n    const orderMatch = sql.match(/ORDER\\s+BY\\s+(.+?)(?:\\s+LIMIT|\\s+OFFSET|$)/i);\n    if (orderMatch) {\n      for (const part of orderMatch[1].split(',')) {\n        const trimmed = part.trim();\n        if (trimmed.toUpperCase().endsWith(' DESC')) {\n          orderBy.push([trimmed.slice(0, -5).trim(), 'DESC']);\n        } else if (trimmed.toUpperCase().endsWith(' ASC')) {\n          orderBy.push([trimmed.slice(0, -4).trim(), 'ASC']);\n        } else {\n          orderBy.push([trimmed, 'ASC']);\n        }\n      }\n    }\n\n    // Extract LIMIT\n    let limit: number | undefined;\n    const limitMatch = sql.match(/LIMIT\\s+(\\d+)/i);\n    if (limitMatch) {\n      limit = parseInt(limitMatch[1], 10);\n    }\n\n    // Extract OFFSET\n    let offset: number | undefined;\n    const offsetMatch = sql.match(/OFFSET\\s+(\\d+)/i);\n    if (offsetMatch) {\n      offset = parseInt(offsetMatch[1], 10);\n    }\n\n    return {\n      operation: 'SELECT',\n      data: { table, columns, where: conditions, orderBy, limit, offset },\n    };\n  }\n\n  private static parseWhere(whereClause: string): Array<[string, string, any]> {\n    const conditions: Array<[string, string, any]> = [];\n    const parts = whereClause.split(/\\s+AND\\s+/i);\n\n    for (const part of parts) {\n      const match = part.match(/(\\w+)\\s*(=|!=|<>|>=|<=|>|<|LIKE|NOT\\s+LIKE)\\s*(.+)/i);\n      if (match) {\n        const col = match[1];\n        let op = match[2].toUpperCase().replace(/\\s+/g, '_');\n        if (op === '<>') op = '!=';\n        const val = SQLParser.parseValue(match[3].trim());\n        conditions.push([col, op, val]);\n      }\n    }\n\n    return conditions;\n  }\n\n  private static parseUpdate(sql: string): ParsedSQL {\n    const match = sql.match(/UPDATE\\s+(\\w+)\\s+SET\\s+(.+?)(?:\\s+WHERE\\s+(.+))?$/is);\n    if (!match) {\n      throw new Error(`Invalid UPDATE: ${sql}`);\n    }\n\n    const table = match[1];\n    const setClause = match[2];\n    const whereClause = match[3];\n\n    // Parse SET clause\n    const updates: Record<string, any> = {};\n    for (const part of setClause.split(',')) {\n      const eqMatch = part.match(/\\s*(\\w+)\\s*=\\s*(.+)\\s*/);\n      if (eqMatch) {\n        updates[eqMatch[1]] = SQLParser.parseValue(eqMatch[2].trim());\n      }\n    }\n\n    let conditions: Array<[string, string, any]> = [];\n    if (whereClause) {\n      conditions = SQLParser.parseWhere(whereClause);\n    }\n\n    return { operation: 'UPDATE', data: { table, updates, where: conditions } };\n  }\n\n  private static parseDelete(sql: string): ParsedSQL {\n    const match = sql.match(/DELETE\\s+FROM\\s+(\\w+)(?:\\s+WHERE\\s+(.+))?$/is);\n    if (!match) {\n      throw new Error(`Invalid DELETE: ${sql}`);\n    }\n\n    const table = match[1];\n    let conditions: Array<[string, string, any]> = [];\n    if (match[2]) {\n      conditions = SQLParser.parseWhere(match[2]);\n    }\n\n    return { operation: 'DELETE', data: { table, where: conditions } };\n  }\n}\n\n/**\n * Interface for database operations required by SQLExecutor.\n */\ninterface DatabaseInterface {\n  get(key: Buffer | string): Promise<Buffer | null>;\n  put(key: Buffer | string, value: Buffer | string): Promise<void>;\n  delete(key: Buffer | string): Promise<void>;\n  scan(prefix: string): Promise<Array<{ key: Buffer; value: Buffer }>>;\n}\n\n/**\n * SQL Executor that operates on a KV database.\n */\nexport class SQLExecutor {\n  private db: DatabaseInterface;\n\n  // Key prefixes for SQL data\n  private readonly TABLE_PREFIX = '_sql/tables/';\n  private readonly SCHEMA_SUFFIX = '/schema';\n  private readonly ROWS_PREFIX = '/rows/';\n  private readonly INDEX_PREFIX = '/indexes/';\n\n  constructor(db: DatabaseInterface) {\n    this.db = db;\n  }\n\n  /**\n   * Execute a SQL statement.\n   */\n  async execute(sql: string): Promise<SQLQueryResult> {\n    const { operation, data } = SQLParser.parse(sql);\n\n    switch (operation) {\n      case 'CREATE_TABLE':\n        return this.createTable(data);\n      case 'DROP_TABLE':\n        return this.dropTable(data);\n      case 'CREATE_INDEX':\n        return this.createIndex(data);\n      case 'DROP_INDEX':\n        return this.dropIndex(data);\n      case 'INSERT':\n        return this.insert(data);\n      case 'SELECT':\n        return this.select(data);\n      case 'UPDATE':\n        return this.update(data);\n      case 'DELETE':\n        return this.deleteRows(data);\n      default:\n        throw new Error(`Unknown operation: ${operation}`);\n    }\n  }\n\n  private schemaKey(table: string): string {\n    return this.TABLE_PREFIX + table + this.SCHEMA_SUFFIX;\n  }\n\n  private rowKey(table: string, rowId: string): string {\n    return this.TABLE_PREFIX + table + this.ROWS_PREFIX + rowId;\n  }\n\n  private rowPrefix(table: string): string {\n    return this.TABLE_PREFIX + table + this.ROWS_PREFIX;\n  }\n\n  private indexMetaKey(table: string, indexName: string): string {\n    return this.TABLE_PREFIX + table + this.INDEX_PREFIX + indexName + '/meta';\n  }\n\n  private indexPrefix(table: string, indexName: string): string {\n    return this.TABLE_PREFIX + table + this.INDEX_PREFIX + indexName + '/';\n  }\n\n  private indexKey(table: string, indexName: string, columnValue: string, rowId: string): string {\n    return this.TABLE_PREFIX + table + this.INDEX_PREFIX + indexName + '/' + columnValue + '/' + rowId;\n  }\n\n  private indexValuePrefix(table: string, indexName: string, columnValue: string): string {\n    return this.TABLE_PREFIX + table + this.INDEX_PREFIX + indexName + '/' + columnValue + '/';\n  }\n\n  private async getSchema(table: string): Promise<TableSchema | null> {\n    const data = await this.db.get(this.schemaKey(table));\n    if (!data) return null;\n    return JSON.parse(data.toString());\n  }\n\n  private async getIndexes(table: string): Promise<Record<string, string>> {\n    // Returns map of index_name -> column_name\n    const indexes: Record<string, string> = {};\n    const prefix = this.TABLE_PREFIX + table + this.INDEX_PREFIX;\n    const pairs = await this.db.scan(prefix);\n\n    for (const { key, value } of pairs) {\n      const keyStr = key.toString();\n      if (keyStr.endsWith('/meta')) {\n        const info: IndexInfo = JSON.parse(value.toString());\n        const parts = keyStr.split('/');\n        if (parts.length >= 5) {\n          const indexName = parts[parts.length - 2];\n          indexes[indexName] = info.column;\n        }\n      }\n    }\n\n    return indexes;\n  }\n\n  private async hasIndexForColumn(table: string, column: string): Promise<{ has: boolean; name: string }> {\n    const indexes = await this.getIndexes(table);\n    for (const [indexName, indexCol] of Object.entries(indexes)) {\n      if (indexCol === column) {\n        return { has: true, name: indexName };\n      }\n    }\n    return { has: false, name: '' };\n  }\n\n  private async lookupByIndex(table: string, indexName: string, value: string): Promise<string[]> {\n    const prefix = this.indexValuePrefix(table, indexName, value);\n    const pairs = await this.db.scan(prefix);\n    return pairs.map(p => p.value.toString());\n  }\n\n  private async updateIndex(\n    table: string,\n    indexName: string,\n    column: string,\n    oldRow: Record<string, any>,\n    newRow: Record<string, any>,\n    rowId: string\n  ): Promise<void> {\n    const oldVal = oldRow[column];\n    const newVal = newRow[column];\n\n    if (oldVal === newVal) {\n      return;\n    }\n\n    // Remove old index entry\n    if (oldVal != null) {\n      const oldKey = this.indexKey(table, indexName, String(oldVal), rowId);\n      await this.db.delete(oldKey);\n    }\n\n    // Add new index entry\n    if (newVal != null) {\n      const newKey = this.indexKey(table, indexName, String(newVal), rowId);\n      await this.db.put(newKey, rowId);\n    }\n  }\n\n  private findIndexedEqualityCondition(\n    table: string,\n    conditions: Array<[string, string, any]>,\n    indexes: Record<string, string>\n  ): [string, any] | null {\n    for (const [col, op, val] of conditions) {\n      if (op === '=' && Object.values(indexes).includes(col)) {\n        return [col, val];\n      }\n    }\n    return null;\n  }\n\n  private async createTable(data: Record<string, any>): Promise<SQLQueryResult> {\n    const table = data.table;\n    const columns = data.columns as Column[];\n    const primaryKey = data.primaryKey;\n\n    // Check if table exists\n    if (await this.getSchema(table)) {\n      throw new Error(`Table '${table}' already exists`);\n    }\n\n    const schema: TableSchema = { name: table, columns, primaryKey };\n    await this.db.put(this.schemaKey(table), JSON.stringify(schema));\n\n    return { rows: [], columns: [], rowsAffected: 0 };\n  }\n\n  private async dropTable(data: Record<string, any>): Promise<SQLQueryResult> {\n    const table = data.table;\n\n    // Delete all indexes first\n    const indexes = await this.getIndexes(table);\n    for (const indexName of Object.keys(indexes)) {\n      const idxPrefix = this.indexPrefix(table, indexName);\n      const idxPairs = await this.db.scan(idxPrefix);\n      for (const { key } of idxPairs) {\n        await this.db.delete(key);\n      }\n      await this.db.delete(this.indexMetaKey(table, indexName));\n    }\n\n    // Delete all rows\n    const prefix = this.rowPrefix(table);\n    const rows = await this.db.scan(prefix);\n    let rowsDeleted = 0;\n\n    for (const { key } of rows) {\n      await this.db.delete(key);\n      rowsDeleted++;\n    }\n\n    // Delete schema\n    await this.db.delete(this.schemaKey(table));\n\n    return { rows: [], columns: [], rowsAffected: rowsDeleted };\n  }\n\n  private async createIndex(data: Record<string, any>): Promise<SQLQueryResult> {\n    const indexName = data.indexName;\n    const table = data.table;\n    const column = data.column;\n\n    const schema = await this.getSchema(table);\n    if (!schema) {\n      throw new Error(`Table '${table}' does not exist`);\n    }\n\n    // Check column exists\n    if (!schema.columns.some(c => c.name === column)) {\n      throw new Error(`Column '${column}' does not exist in table '${table}'`);\n    }\n\n    // Check index doesn't already exist\n    const metaKey = this.indexMetaKey(table, indexName);\n    const existing = await this.db.get(metaKey);\n    if (existing) {\n      throw new Error(`Index '${indexName}' already exists on table '${table}'`);\n    }\n\n    // Store index metadata\n    const meta: IndexInfo = { column, table };\n    await this.db.put(metaKey, JSON.stringify(meta));\n\n    // Build index from existing rows\n    const prefix = this.rowPrefix(table);\n    const pairs = await this.db.scan(prefix);\n    let indexedCount = 0;\n\n    for (const { value } of pairs) {\n      const row = JSON.parse(value.toString());\n      const rowId = row['_id'];\n      const colValue = row[column];\n\n      if (colValue != null) {\n        const idxKey = this.indexKey(table, indexName, String(colValue), rowId);\n        await this.db.put(idxKey, rowId);\n        indexedCount++;\n      }\n    }\n\n    return { rows: [], columns: [], rowsAffected: indexedCount };\n  }\n\n  private async dropIndex(data: Record<string, any>): Promise<SQLQueryResult> {\n    const indexName = data.indexName;\n    const table = data.table;\n\n    // Delete all index entries\n    const idxPrefix = this.indexPrefix(table, indexName);\n    const pairs = await this.db.scan(idxPrefix);\n    let deleted = 0;\n\n    for (const { key } of pairs) {\n      await this.db.delete(key);\n      deleted++;\n    }\n\n    // Delete index metadata\n    await this.db.delete(this.indexMetaKey(table, indexName));\n\n    return { rows: [], columns: [], rowsAffected: deleted };\n  }\n\n  private async insert(data: Record<string, any>): Promise<SQLQueryResult> {\n    const table = data.table;\n    let columns = data.columns as string[] | null;\n    const values = data.values as any[];\n\n    const schema = await this.getSchema(table);\n    if (!schema) {\n      throw new Error(`Table '${table}' does not exist`);\n    }\n\n    // If no columns specified, use schema order\n    if (!columns) {\n      columns = schema.columns.map((c) => c.name);\n    }\n\n    if (columns.length !== values.length) {\n      throw new Error(\n        `Column count (${columns.length}) doesn't match value count (${values.length})`\n      );\n    }\n\n    // Create row object\n    const row: Record<string, any> = {};\n    for (let i = 0; i < columns.length; i++) {\n      row[columns[i]] = values[i];\n    }\n\n    // Generate row ID\n    let rowId: string;\n    if (schema.primaryKey && schema.primaryKey in row) {\n      rowId = String(row[schema.primaryKey]);\n    } else {\n      rowId = uuidv4();\n    }\n    row['_id'] = rowId;\n\n    await this.db.put(this.rowKey(table, rowId), JSON.stringify(row));\n\n    // Maintain indexes\n    const indexes = await this.getIndexes(table);\n    for (const [indexName, indexCol] of Object.entries(indexes)) {\n      if (row[indexCol] != null) {\n        const idxKey = this.indexKey(table, indexName, String(row[indexCol]), rowId);\n        await this.db.put(idxKey, rowId);\n      }\n    }\n\n    return { rows: [], columns: [], rowsAffected: 1 };\n  }\n\n  private async select(data: Record<string, any>): Promise<SQLQueryResult> {\n    const table = data.table;\n    let columns = data.columns as string[];\n    const conditions = data.where as Array<[string, string, any]>;\n    const orderBy = data.orderBy as Array<[string, string]>;\n    const limit = data.limit as number | undefined;\n    const offset = data.offset as number | undefined;\n\n    const schema = await this.getSchema(table);\n    if (!schema) {\n      throw new Error(`Table '${table}' does not exist`);\n    }\n\n    // Get column names\n    if (columns.length === 1 && columns[0] === '*') {\n      columns = schema.columns.map((c) => c.name);\n    }\n\n    // Scan all rows\n    const prefix = this.rowPrefix(table);\n    const scanResults = await this.db.scan(prefix);\n    let rows: Array<Record<string, any>> = [];\n\n    for (const { value } of scanResults) {\n      const row = JSON.parse(value.toString());\n\n      // Apply WHERE conditions\n      if (this.matchesConditions(row, conditions)) {\n        // Project columns\n        const projected: Record<string, any> = {};\n        for (const col of columns) {\n          if (col in row) {\n            projected[col] = row[col];\n          }\n        }\n        rows.push(projected);\n      }\n    }\n\n    // Apply ORDER BY\n    if (orderBy && orderBy.length > 0) {\n      rows.sort((a, b) => {\n        for (const [col, direction] of orderBy) {\n          const aVal = a[col];\n          const bVal = b[col];\n\n          // Handle nulls\n          if (aVal === null || aVal === undefined) return 1;\n          if (bVal === null || bVal === undefined) return -1;\n\n          let cmp = 0;\n          if (aVal < bVal) cmp = -1;\n          else if (aVal > bVal) cmp = 1;\n\n          if (direction === 'DESC') cmp = -cmp;\n          if (cmp !== 0) return cmp;\n        }\n        return 0;\n      });\n    }\n\n    // Apply OFFSET and LIMIT\n    if (offset && offset > 0) {\n      rows = rows.slice(offset);\n    }\n    if (limit !== undefined && limit > 0) {\n      rows = rows.slice(0, limit);\n    }\n\n    return { rows, columns, rowsAffected: 0 };\n  }\n\n  private matchesConditions(\n    row: Record<string, any>,\n    conditions: Array<[string, string, any]>\n  ): boolean {\n    for (const [col, op, val] of conditions) {\n      const rowVal = row[col];\n\n      switch (op) {\n        case '=':\n          if (rowVal !== val) return false;\n          break;\n        case '!=':\n          if (rowVal === val) return false;\n          break;\n        case '>':\n          if (rowVal === null || rowVal === undefined || rowVal <= val) return false;\n          break;\n        case '>=':\n          if (rowVal === null || rowVal === undefined || rowVal < val) return false;\n          break;\n        case '<':\n          if (rowVal === null || rowVal === undefined || rowVal >= val) return false;\n          break;\n        case '<=':\n          if (rowVal === null || rowVal === undefined || rowVal > val) return false;\n          break;\n        case 'LIKE': {\n          if (rowVal === null || rowVal === undefined) return false;\n          const pattern = String(val).replace(/%/g, '.*').replace(/_/g, '.');\n          if (!new RegExp(`^${pattern}$`, 'i').test(String(rowVal))) return false;\n          break;\n        }\n        case 'NOT_LIKE': {\n          if (rowVal === null || rowVal === undefined) return true;\n          const pattern = String(val).replace(/%/g, '.*').replace(/_/g, '.');\n          if (new RegExp(`^${pattern}$`, 'i').test(String(rowVal))) return false;\n          break;\n        }\n      }\n    }\n    return true;\n  }\n\n  private async update(data: Record<string, any>): Promise<SQLQueryResult> {\n    const table = data.table;\n    const updates = data.updates as Record<string, any>;\n    const conditions = data.where as Array<[string, string, any]>;\n\n    const schema = await this.getSchema(table);\n    if (!schema) {\n      throw new Error(`Table '${table}' does not exist`);\n    }\n\n    const indexes = await this.getIndexes(table);\n    let rowsAffected = 0;\n\n    // Try index-accelerated path\n    const indexedCond = this.findIndexedEqualityCondition(table, conditions, indexes);\n\n    if (indexedCond) {\n      // Index-accelerated UPDATE\n      const [col, val] = indexedCond;\n      const indexResult = await this.hasIndexForColumn(table, col);\n      \n      if (indexResult.has) {\n        const rowIds = await this.lookupByIndex(table, indexResult.name, String(val));\n        \n        for (const rowId of rowIds) {\n          const key = this.rowKey(table, rowId);\n          const value = await this.db.get(key);\n          if (!value) continue;\n\n          const oldRow = JSON.parse(value.toString());\n\n          // Apply all WHERE conditions (not just the indexed one)\n          if (!this.matchesConditions(oldRow, conditions)) {\n            continue;\n          }\n\n          // Apply updates\n          const newRow = { ...oldRow };\n          for (const [ucol, uval] of Object.entries(updates)) {\n            newRow[ucol] = uval;\n          }\n\n          // Update indexes for changed columns\n          for (const [idxName, idxCol] of Object.entries(indexes)) {\n            if (idxCol in updates) {\n              await this.updateIndex(table, idxName, idxCol, oldRow, newRow, rowId);\n            }\n          }\n\n          await this.db.put(key, JSON.stringify(newRow));\n          rowsAffected++;\n        }\n      }\n    } else {\n      // Fallback: full table scan\n      const prefix = this.rowPrefix(table);\n      const scanResults = await this.db.scan(prefix);\n\n      for (const { key, value } of scanResults) {\n        const oldRow = JSON.parse(value.toString());\n\n        // Apply WHERE conditions\n        if (this.matchesConditions(oldRow, conditions)) {\n          // Apply updates\n          const newRow = { ...oldRow };\n          for (const [col, val] of Object.entries(updates)) {\n            newRow[col] = val;\n          }\n\n          const rowId = oldRow['_id'];\n\n          // Update indexes for changed columns\n          for (const [idxName, idxCol] of Object.entries(indexes)) {\n            if (idxCol in updates) {\n              await this.updateIndex(table, idxName, idxCol, oldRow, newRow, rowId);\n            }\n          }\n\n          await this.db.put(key, JSON.stringify(newRow));\n          rowsAffected++;\n        }\n      }\n    }\n\n    return { rows: [], columns: [], rowsAffected };\n  }\n\n  private async deleteRows(data: Record<string, any>): Promise<SQLQueryResult> {\n    const table = data.table;\n    const conditions = data.where as Array<[string, string, any]>;\n\n    const schema = await this.getSchema(table);\n    if (!schema) {\n      throw new Error(`Table '${table}' does not exist`);\n    }\n\n    const indexes = await this.getIndexes(table);\n    let rowsAffected = 0;\n\n    // Try index-accelerated path\n    const indexedCond = this.findIndexedEqualityCondition(table, conditions, indexes);\n\n    if (indexedCond) {\n      // Index-accelerated DELETE\n      const [col, val] = indexedCond;\n      const indexResult = await this.hasIndexForColumn(table, col);\n      \n      if (indexResult.has) {\n        const rowIds = await this.lookupByIndex(table, indexResult.name, String(val));\n        const keysToDelete: Buffer[] = [];\n        const rowsToDelete: Array<{ row: Record<string, any>; rowId: string }> = [];\n\n        for (const rowId of rowIds) {\n          const key = this.rowKey(table, rowId);\n          const value = await this.db.get(key);\n          if (!value) continue;\n\n          const row = JSON.parse(value.toString());\n\n          // Apply all WHERE conditions (not just the indexed one)\n          if (this.matchesConditions(row, conditions)) {\n            keysToDelete.push(Buffer.from(key));\n            rowsToDelete.push({ row, rowId });\n          }\n        }\n\n        // Delete rows and update indexes\n        for (let i = 0; i < keysToDelete.length; i++) {\n          const key = keysToDelete[i];\n          const { row, rowId } = rowsToDelete[i];\n\n          // Remove from all indexes\n          for (const [idxName, idxCol] of Object.entries(indexes)) {\n            const emptyRow: Record<string, any> = {};\n            await this.updateIndex(table, idxName, idxCol, row, emptyRow, rowId);\n          }\n\n          await this.db.delete(key);\n          rowsAffected++;\n        }\n      }\n    } else {\n      // Fallback: full table scan\n      const prefix = this.rowPrefix(table);\n      const scanResults = await this.db.scan(prefix);\n      const keysToDelete: Buffer[] = [];\n      const rowsToDelete: Array<{ row: Record<string, any>; rowId: string }> = [];\n\n      for (const { key, value } of scanResults) {\n        const row = JSON.parse(value.toString());\n\n        // Apply WHERE conditions\n        if (this.matchesConditions(row, conditions)) {\n          const rowId = row['_id'];\n          keysToDelete.push(key);\n          rowsToDelete.push({ row, rowId });\n        }\n      }\n\n      // Delete collected rows and update indexes\n      for (let i = 0; i < keysToDelete.length; i++) {\n        const key = keysToDelete[i];\n        const { row, rowId } = rowsToDelete[i];\n\n        // Remove from all indexes\n        for (const [idxName, idxCol] of Object.entries(indexes)) {\n          const emptyRow: Record<string, any> = {};\n          await this.updateIndex(table, idxName, idxCol, row, emptyRow, rowId);\n        }\n\n        await this.db.delete(key);\n        rowsAffected++;\n      }\n    }\n\n    return { rows: [], columns: [], rowsAffected };\n  }\n}\n"]}