juxscript 1.1.240 → 1.1.244

package/lib/storage/TabularDriver.js

@@ -1,731 +0,0 @@
-import { DataFrame } from './DataFrame.js';
-export class TabularDriver {
-    constructor(dbName = 'jux-tabular', storeName = 'tables') {
-        this._db = null;
-        this._dbName = dbName;
-        this._storeName = storeName;
-    }
-    async open() {
-        if (this._db)
-            return this._db;
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open(this._dbName, 1);
-            request.onupgradeneeded = (e) => {
-                const db = e.target.result;
-                if (!db.objectStoreNames.contains(this._storeName)) {
-                    const store = db.createObjectStore(this._storeName, { keyPath: 'id' });
-                    store.createIndex('name', 'name', { unique: false });
-                    store.createIndex('timestamp', 'timestamp', { unique: false });
-                }
-            };
-            request.onsuccess = (e) => {
-                this._db = e.target.result;
-                resolve(this._db);
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    /* ═══════════════════════════════════════════════════
-     * CSV / TSV PARSING
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * ✅ NEW: Auto-detect delimiter from first N lines of CSV
-     * Checks for: , | \t ;
-     */
-    _detectDelimiter(text, sampleLines = 5) {
-        const lines = this._splitLines(text).slice(0, sampleLines).filter(l => l.trim());
-        if (lines.length === 0)
-            return ',';
-        const delimiters = [',', '|', '\t', ';'];
-        const scores = {};
-        delimiters.forEach(delim => {
-            const counts = lines.map(line => {
-                // Count occurrences of delimiter NOT inside quotes
-                let count = 0;
-                let inQuotes = false;
-                for (let i = 0; i < line.length; i++) {
-                    if (line[i] === '"')
-                        inQuotes = !inQuotes;
-                    if (!inQuotes && line[i] === delim)
-                        count++;
-                }
-                return count;
-            });
-            // Delimiter should have consistent count across lines
-            const avg = counts.reduce((sum, c) => sum + c, 0) / counts.length;
-            const variance = counts.reduce((sum, c) => sum + Math.pow(c - avg, 2), 0) / counts.length;
-            // Score: high count, low variance
-            scores[delim] = avg > 0 ? avg / (1 + variance) : 0;
-        });
-        // Return delimiter with highest score
-        const best = Object.entries(scores).sort((a, b) => b[1] - a[1])[0];
-        return best[0];
-    }
-    /**
-     * ✅ NEW: Detect which row contains the header
-     * Looks for first row with mostly string values
-     */
-    _detectHeaderRow(text, delimiter, maxCheck = 10) {
-        const lines = this._splitLines(text).slice(0, maxCheck).filter(l => l.trim());
-        for (let i = 0; i < lines.length; i++) {
-            const values = this._parseLine(lines[i], delimiter);
-            // Skip if mostly empty
-            const nonEmpty = values.filter(v => v.trim()).length;
-            if (nonEmpty < values.length * 0.5)
-                continue;
-            // Check if mostly non-numeric (likely headers)
-            const nonNumeric = values.filter(v => {
-                const trimmed = v.trim();
-                return isNaN(Number(trimmed)) && trimmed !== '';
-            }).length;
-            if (nonNumeric >= values.length * 0.7) {
-                return i;
-            }
-        }
-        return 0; // Fallback to first row
-    }
-    /**
-     * Parse a CSV/TSV string into a DataFrame
-     */
-    parseCSV(text, options = {}) {
-        const { delimiter: userDelimiter, hasHeader = true, maxRows, skipRows: userSkipRows = 0, columns: selectCols, headerRow: userHeaderRow, autoDetectDelimiter = true } = options;
-        // ✅ Auto-detect delimiter if not provided
-        const delimiter = userDelimiter || (autoDetectDelimiter ? this._detectDelimiter(text) : ',');
-        // ✅ Auto-detect header row if not provided
-        const headerRow = userHeaderRow !== undefined ? userHeaderRow : (hasHeader ? this._detectHeaderRow(text, delimiter) : -1);
-        const lines = this._splitLines(text);
-        let headers;
-        // Skip rows before header
-        let startIdx = userSkipRows;
-        if (hasHeader && headerRow >= 0) {
-            const headerLine = lines[headerRow + userSkipRows];
-            if (headerLine) {
-                headers = this._parseLine(headerLine, delimiter);
-                startIdx = headerRow + userSkipRows + 1;
-            }
-            else {
-                const firstLine = this._parseLine(lines[startIdx] || '', delimiter);
-                headers = firstLine.map((_, i) => `col_${i}`);
-            }
-        }
-        else {
-            const firstLine = this._parseLine(lines[startIdx] || '', delimiter);
-            headers = firstLine.map((_, i) => `col_${i}`);
-        }
-        const rows = [];
-        const end = maxRows ? Math.min(startIdx + maxRows, lines.length) : lines.length;
-        for (let i = startIdx; i < end; i++) {
-            if (!lines[i].trim())
-                continue;
-            const values = this._parseLine(lines[i], delimiter);
-            const row = {};
-            headers.forEach((h, j) => {
-                row[h] = this._autoType(values[j]);
-            });
-            rows.push(row);
-        }
-        let df = new DataFrame(rows);
-        if (selectCols) {
-            df = df.select(...selectCols);
-        }
-        return df;
-    }
-    /**
-     * Stream-parse a File into a DataFrame, with progress callback.
-     * Auto-detects XLSX/XLS and routes accordingly.
-     */
-    async streamFile(file, options = {}) {
-        const ext = file.name.split('.').pop()?.toLowerCase();
-        if (ext === 'xlsx' || ext === 'xls') {
-            return this._parseXLSX(file, options);
-        }
-        const { delimiter = file.name.endsWith('.tsv') ? '\t' : ',', hasHeader = true, chunkSize = 64 * 1024, onProgress, maxRows, skipRows = 0, columns: selectCols } = options;
-        const totalSize = file.size;
-        let bytesRead = 0;
-        let headers = null;
-        let lineBuffer = '';
-        let rowCount = 0;
-        let skipped = 0;
-        const rows = [];
-        const reader = file.stream().getReader();
-        const decoder = new TextDecoder();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            bytesRead += value.byteLength;
-            lineBuffer += decoder.decode(value, { stream: !done });
-            const lines = lineBuffer.split('\n');
-            lineBuffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                if (!headers && hasHeader) {
-                    headers = this._parseLine(line, delimiter);
-                    continue;
-                }
-                if (!headers) {
-                    const vals = this._parseLine(line, delimiter);
-                    headers = vals.map((_, i) => `col_${i}`);
-                }
-                if (skipped < skipRows) {
-                    skipped++;
-                    continue;
-                }
-                if (maxRows && rowCount >= maxRows)
-                    break;
-                const values = this._parseLine(line, delimiter);
-                const row = {};
-                headers.forEach((h, j) => {
-                    row[h] = this._autoType(values[j]);
-                });
-                rows.push(row);
-                rowCount++;
-            }
-            if (onProgress) {
-                onProgress(bytesRead, totalSize);
-            }
-            if (maxRows && rowCount >= maxRows)
-                break;
-        }
-        // Handle remaining buffer
-        if (lineBuffer.trim() && (!maxRows || rowCount < maxRows)) {
-            if (!headers) {
-                headers = this._parseLine(lineBuffer, delimiter).map((_, i) => `col_${i}`);
-            }
-            else {
-                const values = this._parseLine(lineBuffer, delimiter);
-                const row = {};
-                headers.forEach((h, j) => {
-                    row[h] = this._autoType(values[j]);
-                });
-                rows.push(row);
-            }
-        }
-        if (onProgress)
-            onProgress(totalSize, totalSize);
-        let df = new DataFrame(rows);
-        if (selectCols)
-            df = df.select(...selectCols);
-        return df;
-    }
-    /* ═══════════════════════════════════════════════════
-     * XLSX / XLS PARSING (ExcelJS)
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Parse an XLSX/XLS file into a DataFrame using ExcelJS
-     */
-    async _parseXLSX(file, options = {}) {
-        const { maxRows, skipRows = 0, columns: selectCols, sheet, onProgress, hasHeader = true } = options;
-        let ExcelJS;
-        try {
-            ExcelJS = await import('exceljs');
-        }
-        catch {
-            throw new Error('XLSX support requires the "exceljs" package. Install it with: npm install exceljs');
-        }
-        if (onProgress)
-            onProgress(0, file.size);
-        const buffer = await file.arrayBuffer();
-        if (onProgress)
-            onProgress(file.size * 0.5, file.size);
-        const workbook = new ExcelJS.Workbook();
-        await workbook.xlsx.load(buffer);
-        // Select sheet
-        let worksheet;
-        if (typeof sheet === 'number') {
-            worksheet = workbook.worksheets[sheet] || workbook.worksheets[0];
-        }
-        else if (typeof sheet === 'string') {
-            worksheet = workbook.getWorksheet(sheet) || workbook.worksheets[0];
-        }
-        else {
-            worksheet = workbook.worksheets[0];
-        }
-        if (!worksheet) {
-            const names = workbook.worksheets.map((ws) => ws.name).join(', ');
-            throw new Error(`No worksheet found. Available: ${names}`);
-        }
-        if (onProgress)
-            onProgress(file.size * 0.7, file.size);
-        // Read all rows
-        const allRows = [];
-        let headers = null;
-        worksheet.eachRow({ includeEmpty: false }, (row, rowNumber) => {
-            const values = this._excelRowToArray(row, worksheet.columnCount);
-            if (!headers && hasHeader) {
-                headers = values.map((v, i) => {
-                    if (v === null || v === undefined || String(v).trim() === '')
-                        return `col_${i}`;
-                    return String(v).trim();
-                });
-                return;
-            }
-            if (!headers) {
-                headers = values.map((_, i) => `col_${i}`);
-            }
-            const rowObj = {};
-            headers.forEach((h, j) => {
-                rowObj[h] = this._autoType(values[j] === null || values[j] === undefined ? '' : String(values[j]));
-            });
-            allRows.push(rowObj);
-        });
-        if (onProgress)
-            onProgress(file.size * 0.9, file.size);
-        let rows = allRows;
-        if (skipRows > 0)
-            rows = rows.slice(skipRows);
-        if (maxRows !== undefined)
-            rows = rows.slice(0, maxRows);
-        if (onProgress)
-            onProgress(file.size, file.size);
-        let df = new DataFrame(rows);
-        if (selectCols)
-            df = df.select(...selectCols);
-        return df;
-    }
-    /**
-     * Get sheet names from an XLSX file
-     */
-    async getSheetNames(file) {
-        let ExcelJS;
-        try {
-            ExcelJS = await import('exceljs');
-        }
-        catch {
-            throw new Error('XLSX support requires the "exceljs" package. Install it with: npm install exceljs');
-        }
-        const buffer = await file.arrayBuffer();
-        const workbook = new ExcelJS.Workbook();
-        await workbook.xlsx.load(buffer);
-        return workbook.worksheets.map((ws) => ws.name);
-    }
-    /* ═══════════════════════════════════════════════════
-     * INDEXEDDB PERSISTENCE
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Store a DataFrame to IndexedDB
-     */
-    async store(name, df, metadata) {
-        const db = await this.open();
-        const table = {
-            id: `${name}-${Date.now()}`,
-            name,
-            columns: df.columns,
-            rows: df.toRows().map(row => df.columns.map(c => row[c])),
-            rowCount: df.height,
-            delimiter: ',',
-            timestamp: Date.now(),
-            metadata
-        };
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readwrite');
-            const store = tx.objectStore(this._storeName);
-            const request = store.put(table);
-            request.onsuccess = () => resolve(table.id);
-            request.onerror = () => reject(request.error);
-        });
-    }
-    /**
-     * Load a DataFrame from IndexedDB by ID
-     */
-    async load(id) {
-        const db = await this.open();
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readonly');
-            const store = tx.objectStore(this._storeName);
-            const request = store.get(id);
-            request.onsuccess = () => {
-                const table = request.result;
-                if (!table)
-                    return resolve(null);
-                const rows = table.rows.map(row => {
-                    const obj = {};
-                    table.columns.forEach((col, i) => { obj[col] = row[i]; });
-                    return obj;
-                });
-                resolve(new DataFrame(rows));
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    /**
-     * Load the most recent table by name
-     */
-    async loadByName(name) {
-        const db = await this.open();
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readonly');
-            const store = tx.objectStore(this._storeName);
-            const index = store.index('name');
-            const request = index.getAll(name);
-            request.onsuccess = () => {
-                const tables = request.result || [];
-                if (tables.length === 0)
-                    return resolve(null);
-                tables.sort((a, b) => b.timestamp - a.timestamp);
-                const table = tables[0];
-                const rows = table.rows.map(row => {
-                    const obj = {};
-                    table.columns.forEach((col, i) => { obj[col] = row[i]; });
-                    return obj;
-                });
-                resolve(new DataFrame(rows));
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    /**
-     * List all stored tables (metadata only)
-     */
-    async list() {
-        const db = await this.open();
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readonly');
-            const store = tx.objectStore(this._storeName);
-            const request = store.getAll();
-            request.onsuccess = () => {
-                resolve((request.result || []).map((t) => ({
-                    id: t.id,
-                    name: t.name,
-                    columns: t.columns,
-                    rowCount: t.rowCount,
-                    timestamp: t.timestamp
-                })));
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    /**
-     * Delete a stored table
-     */
-    async delete(id) {
-        const db = await this.open();
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readwrite');
-            const store = tx.objectStore(this._storeName);
-            const request = store.delete(id);
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async clear() {
-        const db = await this.open();
-        return new Promise((resolve, reject) => {
-            const tx = db.transaction(this._storeName, 'readwrite');
-            const store = tx.objectStore(this._storeName);
-            const request = store.clear();
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-        });
-    }
-    /* ═══════════════════════════════════════════════════
-     * STREAM FROM URL
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Fetch and stream-parse a remote CSV/TSV file
-     */
-    async fetch(url, options = {}) {
-        const response = await globalThis.fetch(url);
-        if (!response.ok)
-            throw new Error(`Failed to fetch: ${response.status}`);
-        if (!response.body)
-            throw new Error('No response body');
-        const contentLength = Number(response.headers.get('content-length')) || null;
-        const ext = url.split('.').pop()?.toLowerCase();
-        const delimiter = options.delimiter ?? (ext === 'tsv' ? '\t' : ',');
-        const { hasHeader = true, chunkSize, onProgress, maxRows, skipRows = 0, columns: selectCols } = options;
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let headers = null;
-        let lineBuffer = '';
-        let rowCount = 0;
-        let skipped = 0;
-        let bytesRead = 0;
-        const rows = [];
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            bytesRead += value.byteLength;
-            lineBuffer += decoder.decode(value, { stream: true });
-            const lines = lineBuffer.split('\n');
-            lineBuffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                if (!headers && hasHeader) {
-                    headers = this._parseLine(line, delimiter);
-                    continue;
-                }
-                if (!headers) {
-                    const vals = this._parseLine(line, delimiter);
-                    headers = vals.map((_, i) => `col_${i}`);
-                }
-                if (skipped < skipRows) {
-                    skipped++;
-                    continue;
-                }
-                if (maxRows && rowCount >= maxRows)
-                    break;
-                const values = this._parseLine(line, delimiter);
-                const row = {};
-                headers.forEach((h, j) => { row[h] = this._autoType(values[j]); });
-                rows.push(row);
-                rowCount++;
-            }
-            if (onProgress)
-                onProgress(bytesRead, contentLength);
-            if (maxRows && rowCount >= maxRows)
-                break;
-        }
-        if (lineBuffer.trim() && (!maxRows || rowCount < maxRows)) {
-            if (headers) {
-                const values = this._parseLine(lineBuffer, delimiter);
-                const row = {};
-                headers.forEach((h, j) => { row[h] = this._autoType(values[j]); });
-                rows.push(row);
-            }
-        }
-        if (onProgress)
-            onProgress(bytesRead, bytesRead);
-        let df = new DataFrame(rows);
-        if (selectCols)
-            df = df.select(...selectCols);
-        return df;
-    }
-    /**
-     * Read raw cell values from first sheet of an Excel file.
-     * Returns rows with their 0-based row indices.
-     * Used by both the preview UI and the parser to ensure consistency.
-     */
-    async readRawExcelRows(file, maxRows = 15) {
-        let ExcelJS;
-        try {
-            ExcelJS = await import('exceljs');
-        }
-        catch {
-            throw new Error('XLSX support requires the "exceljs" package.');
-        }
-        const buffer = await file.arrayBuffer();
-        const workbook = new ExcelJS.Workbook();
-        await workbook.xlsx.load(buffer);
-        const worksheet = workbook.worksheets[0];
-        if (!worksheet)
-            return [];
-        const colCount = worksheet.columnCount;
-        const rows = [];
-        let count = 0;
-        // ExcelJS eachRow gives 1-based rowNumber; we expose 0-based to the UI
-        // But we need to also show truly empty rows, so iterate by index
-        const totalRows = Math.min(worksheet.rowCount, maxRows);
-        for (let r = 1; r <= totalRows; r++) {
-            const row = worksheet.getRow(r);
-            const values = this._excelRowToArray(row, colCount);
-            // sheetRow is 0-based (r-1) to match what we pass back to streamFileMultiSheet
-            rows.push({ sheetRow: r - 1, values });
-            count++;
-            if (count >= maxRows)
-                break;
-        }
-        console.log(`[readRawExcelRows] ${rows.length} rows, colCount=${colCount}`);
-        rows.forEach(r => console.log(`  sheetRow ${r.sheetRow}:`, r.values.slice(0, 5)));
-        return rows;
-    }
-    /**
-     * Stream Excel file with optional headerRow override.
-     * headerRow is 0-based (same as sheetRow from readRawExcelRows).
-     */
-    async streamFileMultiSheet(file, options = {}) {
-        const { maxSheetSize = 100000, onProgress, headerRow = 0 } = options;
-        let ExcelJS;
-        try {
-            ExcelJS = await import('exceljs');
-        }
-        catch {
-            throw new Error('XLSX support requires the "exceljs" package. Install it with: npm install exceljs');
-        }
-        if (onProgress)
-            onProgress(0, file.size);
-        const buffer = await file.arrayBuffer();
-        if (onProgress)
-            onProgress(file.size * 0.3, file.size);
-        const workbook = new ExcelJS.Workbook();
-        await workbook.xlsx.load(buffer);
-        const sheets = {};
-        const totalSheets = workbook.worksheets.length;
-        let processedSheets = 0;
-        for (const worksheet of workbook.worksheets) {
-            const sheetName = worksheet.name;
-            const colCount = worksheet.columnCount;
-            const rowCount = worksheet.rowCount;
-            if (rowCount === 0 || colCount === 0) {
-                processedSheets++;
-                continue;
-            }
-            // headerRow is 0-based; ExcelJS rows are 1-based
-            const headerExcelRow = headerRow + 1;
-            console.log(`[TabularDriver] Sheet "${sheetName}": rowCount=${rowCount}, colCount=${colCount}`);
-            console.log(`[TabularDriver] headerRow=${headerRow} (0-based), excelRow=${headerExcelRow} (1-based)`);
-            if (headerExcelRow > rowCount) {
-                console.warn(`[TabularDriver] headerRow ${headerRow} exceeds rowCount ${rowCount}`);
-                processedSheets++;
-                continue;
-            }
-            // Read header row
-            const headerRowObj = worksheet.getRow(headerExcelRow);
-            const headerValues = this._excelRowToArray(headerRowObj, colCount);
-            console.log(`[TabularDriver] Raw header values at row ${headerRow}:`, headerValues);
-            const headers = headerValues.map((h, i) => {
-                if (h === null || h === undefined || String(h).trim() === '') {
-                    return `__EMPTY${i > 0 ? '_' + i : ''}`;
-                }
-                return String(h).trim();
-            });
-            const validHeaders = headers.filter(h => !h.startsWith('__EMPTY'));
-            console.log(`[TabularDriver] Headers (${validHeaders.length} valid / ${headers.length} total):`, headers);
-            if (validHeaders.length === 0) {
-                console.warn(`[TabularDriver] No valid headers found at row ${headerRow} in sheet "${sheetName}"`);
-                // Debug surrounding rows
-                for (let debugR = Math.max(1, headerExcelRow - 2); debugR <= Math.min(rowCount, headerExcelRow + 2); debugR++) {
-                    const debugRow = worksheet.getRow(debugR);
-                    console.log(`[TabularDriver]   row ${debugR - 1}:`, this._excelRowToArray(debugRow, colCount));
-                }
-                processedSheets++;
-                continue;
-            }
-            // Build data rows: everything after the header row
-            const rows = [];
-            const maxDataRow = Math.min(rowCount, headerExcelRow + maxSheetSize);
-            for (let r = headerExcelRow + 1; r <= maxDataRow; r++) {
-                const row = worksheet.getRow(r);
-                const rowData = this._excelRowToArray(row, colCount);
-                // Skip completely empty rows
-                const hasContent = rowData.some((cell) => cell !== null && cell !== undefined && String(cell).trim() !== '');
-                if (!hasContent)
-                    continue;
-                const rowObj = {};
-                for (let j = 0; j < headers.length; j++) {
-                    rowObj[headers[j]] = rowData[j];
-                }
-                rows.push(rowObj);
-            }
-            console.log(`[TabularDriver] Built ${rows.length} data rows for sheet "${sheetName}"`);
-            if (rows.length > 0) {
-                console.log(`[TabularDriver] First row:`, rows[0]);
-            }
-            if (rows.length > 0) {
-                sheets[sheetName] = new DataFrame(rows);
-            }
-            processedSheets++;
-            if (onProgress) {
-                const progress = 0.3 + (0.6 * (processedSheets / totalSheets));
-                onProgress(file.size * progress, file.size);
-            }
-        }
-        if (onProgress)
-            onProgress(file.size, file.size);
-        return sheets;
-    }
-    /**
-     * Extract cell values from an ExcelJS row into a plain array.
-     * ExcelJS row.values is 1-based (index 0 is undefined), so we normalize.
-     */
-    _excelRowToArray(row, colCount) {
-        const values = [];
-        for (let c = 1; c <= colCount; c++) {
-            const cell = row.getCell(c);
-            if (!cell || cell.value === null || cell.value === undefined) {
-                values.push(null);
-            }
-            else if (cell.type === 8 /* FormulaType */ && cell.result !== undefined) {
-                values.push(cell.result);
-            }
-            else if (typeof cell.value === 'object' && cell.value !== null) {
-                // Handle rich text, hyperlinks, etc.
-                if (cell.value.richText) {
-                    values.push(cell.value.richText.map((rt) => rt.text).join(''));
-                }
-                else if (cell.value.text) {
-                    values.push(cell.value.text);
-                }
-                else if (cell.value.hyperlink) {
-                    values.push(cell.value.text || cell.value.hyperlink);
-                }
-                else {
-                    values.push(String(cell.value));
-                }
-            }
-            else {
-                values.push(cell.value);
-            }
-        }
-        return values;
-    }
-    /* ═══════════════════════════════════════════════════
-     * INTERNAL PARSING HELPERS
-     * ═══════════════════════════════════════════════════ */
-    _splitLines(text) {
-        return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
-    }
-    _parseLine(line, delimiter) {
-        const result = [];
-        let current = '';
-        let inQuotes = false;
-        for (let i = 0; i < line.length; i++) {
-            const ch = line[i];
-            if (inQuotes) {
-                if (ch === '"') {
-                    if (i + 1 < line.length && line[i + 1] === '"') {
-                        current += '"';
-                        i++;
-                    }
-                    else {
-                        inQuotes = false;
-                    }
-                }
-                else {
-                    current += ch;
-                }
-            }
-            else {
-                if (ch === '"') {
-                    inQuotes = true;
-                }
-                else if (ch === delimiter) {
-                    result.push(current.trim());
-                    current = '';
-                }
-                else {
-                    current += ch;
-                }
-            }
-        }
-        result.push(current.trim());
-        return result;
-    }
-    _autoType(value) {
-        if (value === undefined || value === '' || value === null)
-            return null;
-        if (value === 'true')
-            return true;
-        if (value === 'false')
-            return false;
-        const num = Number(value);
-        if (!isNaN(num) && value.trim() !== '')
-            return num;
-        return value;
-    }
-    close() {
-        if (this._db) {
-            this._db.close();
-            this._db = null;
-        }
-    }
-}
-/**
- * Factory
- */
-export function tabularDriver(dbName, storeName) {
-    return new TabularDriver(dbName, storeName);
-}