juxscript 1.1.239 → 1.1.243

package/lib/storage/DataFrame.js

@@ -1,1022 +0,0 @@
-/**
- * DataFrame - A pandas-like data manipulation class for JavaScript
- *
- * Core capabilities:
- * - Column operations (select, drop, rename, reorder)
- * - Row operations (filter, head, tail, sample, slice)
- * - Data transformation (withColumn, apply, map)
- * - Aggregation (groupBy, agg, pivot)
- * - Joins (merge, concat, union)
- * - Type inference and conversion
- * - Sorting and indexing
- * - Statistics and describe
- * - Missing data handling
- */
-export class DataFrame {
-    constructor(data, options = {}) {
-        this._inferTypes = options.inferTypes ?? true;
-        this._schema = new Map();
-        if (data instanceof DataFrame) {
-            // Clone from another DataFrame
-            this._columns = [...data._columns];
-            this._data = new Map();
-            data._columns.forEach(col => {
-                this._data.set(col, [...data._data.get(col)]);
-            });
-            this._height = data._height;
-            this._schema = new Map(data._schema);
-        }
-        else if (Array.isArray(data)) {
-            // Row-oriented: [{col1: val1, col2: val2}, ...]
-            this._initFromRows(data, options.columns);
-        }
-        else {
-            // Column-oriented: {col1: [val1, val2], col2: [val1, val2]}
-            this._initFromColumns(data, options.columns);
-        }
-        if (this._inferTypes) {
-            this._inferSchema();
-        }
-    }
-    _initFromRows(rows, columnOrder) {
-        if (rows.length === 0) {
-            this._columns = columnOrder || [];
-            this._data = new Map();
-            this._height = 0;
-            return;
-        }
-        // Get all unique columns across all rows
-        const colSet = new Set();
-        rows.forEach(row => Object.keys(row).forEach(k => colSet.add(k)));
-        this._columns = columnOrder || Array.from(colSet);
-        this._data = new Map();
-        this._height = rows.length;
-        this._columns.forEach(col => {
-            this._data.set(col, rows.map(row => row[col] ?? null));
-        });
-    }
-    _initFromColumns(cols, columnOrder) {
-        this._columns = columnOrder || Object.keys(cols);
-        this._data = new Map();
-        const lengths = this._columns.map(c => cols[c]?.length ?? 0);
-        this._height = Math.max(0, ...lengths);
-        this._columns.forEach(col => {
-            const values = cols[col] || [];
-            // Pad shorter columns with null
-            const padded = [...values];
-            while (padded.length < this._height) {
-                padded.push(null);
-            }
-            this._data.set(col, padded);
-        });
-    }
-    _inferSchema() {
-        this._columns.forEach(col => {
-            const values = this._data.get(col);
-            const schema = this._inferColumnSchema(col, values);
-            this._schema.set(col, schema);
-        });
-    }
-    _inferColumnSchema(name, values) {
-        let hasNull = false;
-        let hasString = false;
-        let hasNumber = false;
-        let hasBoolean = false;
-        let hasDate = false;
-        let min = undefined;
-        let max = undefined;
-        const uniqueValues = new Set();
-        values.forEach(v => {
-            if (v === null || v === undefined || v === '') {
-                hasNull = true;
-                return;
-            }
-            uniqueValues.add(v);
-            if (typeof v === 'boolean') {
-                hasBoolean = true;
-            }
-            else if (typeof v === 'number' && !isNaN(v)) {
-                hasNumber = true;
-                if (min === undefined || v < min)
-                    min = v;
-                if (max === undefined || v > max)
-                    max = v;
-            }
-            else if (v instanceof Date) {
-                hasDate = true;
-            }
-            else if (typeof v === 'string') {
-                // Try to parse as number
-                const num = Number(v);
-                if (!isNaN(num) && v.trim() !== '') {
-                    hasNumber = true;
-                    if (min === undefined || num < min)
-                        min = num;
-                    if (max === undefined || num > max)
-                        max = num;
-                }
-                else if (v === 'true' || v === 'false') {
-                    hasBoolean = true;
-                }
-                else {
-                    hasString = true;
-                }
-            }
-        });
-        let dtype = 'null';
-        const typeCount = [hasString, hasNumber, hasBoolean, hasDate].filter(Boolean).length;
-        if (typeCount === 0) {
-            dtype = 'null';
-        }
-        else if (typeCount > 1) {
-            dtype = 'mixed';
-        }
-        else if (hasNumber) {
-            dtype = 'number';
-        }
-        else if (hasBoolean) {
-            dtype = 'boolean';
-        }
-        else if (hasDate) {
-            dtype = 'date';
-        }
-        else {
-            dtype = 'string';
-        }
-        return {
-            name,
-            dtype,
-            nullable: hasNull,
-            unique: uniqueValues.size,
-            min,
-            max
-        };
-    }
-    /* ═══════════════════════════════════════════════════
-     * ACCESSORS
-     * ═══════════════════════════════════════════════════ */
-    get columns() {
-        return [...this._columns];
-    }
-    get height() {
-        return this._height;
-    }
-    get width() {
-        return this._columns.length;
-    }
-    get shape() {
-        return [this._height, this._columns.length];
-    }
-    get dtypes() {
-        const result = {};
-        this._schema.forEach((schema, col) => {
-            result[col] = schema.dtype;
-        });
-        return result;
-    }
-    get schema() {
-        return this._columns.map(col => this._schema.get(col));
-    }
-    get isEmpty() {
-        return this._height === 0;
-    }
-    /* ═══════════════════════════════════════════════════
-     * DATA ACCESS
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Get a column as an array
-     */
-    col(name) {
-        const data = this._data.get(name);
-        if (!data)
-            throw new Error(`Column '${name}' not found`);
-        return [...data];
-    }
-    /**
-     * Get column (alias for col)
-     */
-    getColumn(name) {
-        return this.col(name);
-    }
-    /**
-     * Get a single row by index
-     */
-    row(index) {
-        if (index < 0 || index >= this._height) {
-            throw new Error(`Row index ${index} out of bounds`);
-        }
-        const result = {};
-        this._columns.forEach(col => {
-            result[col] = this._data.get(col)[index];
-        });
-        return result;
-    }
-    /**
-     * Get value at specific row and column
-     */
-    at(row, col) {
-        const data = this._data.get(col);
-        if (!data)
-            throw new Error(`Column '${col}' not found`);
-        if (row < 0 || row >= this._height)
-            throw new Error(`Row index ${row} out of bounds`);
-        return data[row];
-    }
-    /**
-     * Set value at specific row and column (mutates!)
-     */
-    setAt(row, col, value) {
-        const data = this._data.get(col);
-        if (!data)
-            throw new Error(`Column '${col}' not found`);
-        if (row < 0 || row >= this._height)
-            throw new Error(`Row index ${row} out of bounds`);
-        data[row] = value;
-        return this;
-    }
-    /**
-     * Convert to array of row objects
-     */
-    toRows() {
-        const rows = [];
-        for (let i = 0; i < this._height; i++) {
-            rows.push(this.row(i));
-        }
-        return rows;
-    }
-    /**
-     * Convert to column-oriented object
-     */
-    toColumns() {
-        const result = {};
-        this._columns.forEach(col => {
-            result[col] = [...this._data.get(col)];
-        });
-        return result;
-    }
-    /**
-     * Get distinct/unique values in a column
-     */
-    distinct(column) {
-        const data = this._data.get(column);
-        if (!data)
-            throw new Error(`Column '${column}' not found`);
-        return [...new Set(data)];
-    }
-    /**
-     * Alias for distinct
-     */
-    unique(column) {
-        return this.distinct(column);
-    }
-    /**
-     * Count occurrences of each value in a column
-     */
-    valueCounts(column) {
-        const data = this._data.get(column);
-        if (!data)
-            throw new Error(`Column '${column}' not found`);
-        const counts = {};
-        data.forEach(v => {
-            const key = v === null ? '__null__' : String(v);
-            counts[key] = (counts[key] || 0) + 1;
-        });
-        return counts;
-    }
-    /* ═══════════════════════════════════════════════════
-     * COLUMN OPERATIONS
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Select specific columns
-     */
-    select(...cols) {
-        const missing = cols.filter(c => !this._data.has(c));
-        if (missing.length > 0) {
-            throw new Error(`Columns not found: ${missing.join(', ')}`);
-        }
-        const newData = {};
-        cols.forEach(col => {
-            newData[col] = [...this._data.get(col)];
-        });
-        return new DataFrame(newData, { columns: cols, inferTypes: this._inferTypes });
-    }
-    /**
-     * Drop columns
-     */
-    drop(...cols) {
-        const keepCols = this._columns.filter(c => !cols.includes(c));
-        return this.select(...keepCols);
-    }
-    /**
-     * Rename columns
-     */
-    rename(mapping) {
-        const newData = {};
-        const newCols = [];
-        this._columns.forEach(col => {
-            const newName = mapping[col] || col;
-            newCols.push(newName);
-            newData[newName] = [...this._data.get(col)];
-        });
-        return new DataFrame(newData, { columns: newCols, inferTypes: this._inferTypes });
-    }
-    /**
-     * Reorder columns
-     */
-    reorder(...cols) {
-        // Include any columns not specified at the end
-        const remaining = this._columns.filter(c => !cols.includes(c));
-        return this.select(...cols, ...remaining);
-    }
-    /**
-     * Add or replace a column with computed values
-     */
-    withColumn(name, fn) {
-        const newValues = this.toRows().map((row, i) => fn(row, i));
-        const newData = {};
-        this._columns.forEach(col => {
-            newData[col] = [...this._data.get(col)];
-        });
-        newData[name] = newValues;
-        const newCols = this._columns.includes(name)
-            ? this._columns
-            : [...this._columns, name];
-        return new DataFrame(newData, { columns: newCols, inferTypes: this._inferTypes });
-    }
-    /**
-     * Add multiple computed columns at once
-     */
-    withColumns(columns) {
-        let result = this;
-        Object.entries(columns).forEach(([name, fn]) => {
-            result = result.withColumn(name, fn);
-        });
-        return result;
-    }
-    /**
-     * Cast column to a specific type
-     */
-    asType(column, dtype) {
-        return this.withColumn(column, (row) => {
-            const val = row[column];
-            if (val === null || val === undefined)
-                return null;
-            switch (dtype) {
-                case 'string':
-                    return String(val);
-                case 'number':
-                    const num = Number(val);
-                    return isNaN(num) ? null : num;
-                case 'boolean':
-                    if (typeof val === 'boolean')
-                        return val;
-                    if (val === 'true' || val === '1' || val === 1)
-                        return true;
-                    if (val === 'false' || val === '0' || val === 0)
-                        return false;
-                    return null;
-                case 'date':
-                    const date = new Date(val);
-                    return isNaN(date.getTime()) ? null : date;
-                default:
-                    return val;
-            }
-        });
-    }
-    /* ═══════════════════════════════════════════════════
-     * ROW OPERATIONS
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Filter rows by predicate
-     */
-    filter(predicate) {
-        const rows = this.toRows();
-        const filtered = rows.filter((row, i) => predicate(row, i));
-        return new DataFrame(filtered, { columns: this._columns, inferTypes: this._inferTypes });
-    }
-    /**
-     * Filter with SQL-like where clause
-     */
-    where(col, op, value) {
-        return this.filter(row => {
-            const v = row[col];
-            switch (op) {
-                case '==': return v === value;
-                case '!=': return v !== value;
-                case '>': return v > value;
-                case '<': return v < value;
-                case '>=': return v >= value;
-                case '<=': return v <= value;
-                case 'in': return Array.isArray(value) && value.includes(v);
-                case 'not in': return Array.isArray(value) && !value.includes(v);
-                case 'contains': return String(v).includes(String(value));
-                case 'startsWith': return String(v).startsWith(String(value));
-                case 'endsWith': return String(v).endsWith(String(value));
-                case 'isNull': return v === null || v === undefined || v === '';
-                case 'notNull': return v !== null && v !== undefined && v !== '';
-                default: return true;
-            }
-        });
-    }
-    /**
-     * Get first N rows
-     */
-    head(n = 5) {
-        return this.slice(0, n);
-    }
-    /**
-     * Get last N rows
-     */
-    tail(n = 5) {
-        return this.slice(Math.max(0, this._height - n));
-    }
-    /**
-     * Slice rows by index range
-     */
-    slice(start, end) {
-        const rows = this.toRows().slice(start, end);
-        return new DataFrame(rows, { columns: this._columns, inferTypes: this._inferTypes });
-    }
-    /**
-     * Get random sample of rows
-     */
-    sample(n, seed) {
-        const rows = this.toRows();
-        const shuffled = [...rows];
-        // Simple shuffle (use seed if provided for reproducibility)
-        for (let i = shuffled.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-        }
-        return new DataFrame(shuffled.slice(0, n), { columns: this._columns, inferTypes: this._inferTypes });
-    }
-    /**
-     * Drop duplicate rows
-     */
-    dropDuplicates(columns) {
-        const cols = columns || this._columns;
-        const seen = new Set();
-        const rows = this.toRows().filter(row => {
-            const key = cols.map(c => JSON.stringify(row[c])).join('|');
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
-        return new DataFrame(rows, { columns: this._columns, inferTypes: this._inferTypes });
-    }
-    /**
-     * Drop rows with null values
-     */
-    dropna(columns) {
-        const cols = columns || this._columns;
-        return this.filter(row => {
-            return cols.every(c => row[c] !== null && row[c] !== undefined && row[c] !== '');
-        });
-    }
-    /**
-     * Fill null values
-     */
-    fillna(value, columns) {
-        const cols = columns || this._columns;
-        let result = this;
-        cols.forEach(col => {
-            result = result.withColumn(col, row => {
-                const v = row[col];
-                return (v === null || v === undefined || v === '') ? value : v;
-            });
-        });
-        return result;
-    }
-    /* ═══════════════════════════════════════════════════
-     * SORTING
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Sort by column(s)
-     */
-    sort(column, descending = false) {
-        const cols = Array.isArray(column) ? column : [column];
-        const descs = Array.isArray(descending) ? descending : cols.map(() => descending);
-        const rows = this.toRows();
-        rows.sort((a, b) => {
-            for (let i = 0; i < cols.length; i++) {
-                const col = cols[i];
-                const desc = descs[i] || false;
-                const aVal = a[col];
-                const bVal = b[col];
-                if (aVal === bVal)
-                    continue;
-                if (aVal === null || aVal === undefined)
-                    return 1;
-                if (bVal === null || bVal === undefined)
-                    return -1;
-                const cmp = aVal < bVal ? -1 : 1;
-                return desc ? -cmp : cmp;
-            }
-            return 0;
-        });
-        return new DataFrame(rows, { columns: this._columns, inferTypes: this._inferTypes });
-    }
-    /**
-     * Sort descending (shorthand)
-     */
-    sortDesc(column) {
-        return this.sort(column, true);
-    }
-    /* ═══════════════════════════════════════════════════
-     * AGGREGATION
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Group by column(s) and aggregate
-     */
-    groupBy(columns) {
-        return new GroupedDataFrame(this, Array.isArray(columns) ? columns : [columns]);
-    }
-    /**
-     * Aggregate entire DataFrame
-     */
-    agg(aggregations) {
-        const result = {};
-        Object.entries(aggregations).forEach(([col, aggFn]) => {
-            const values = this._data.get(col);
-            if (!values)
-                throw new Error(`Column '${col}' not found`);
-            const nonNull = values.filter(v => v !== null && v !== undefined);
-            if (typeof aggFn === 'function') {
-                result[col] = aggFn(nonNull);
-            }
-            else {
-                switch (aggFn) {
-                    case 'sum':
-                        result[col] = nonNull.reduce((a, b) => a + Number(b), 0);
-                        break;
-                    case 'mean':
-                        result[col] = nonNull.length > 0
-                            ? nonNull.reduce((a, b) => a + Number(b), 0) / nonNull.length
-                            : null;
-                        break;
-                    case 'min':
-                        result[col] = nonNull.length > 0 ? Math.min(...nonNull.map(Number)) : null;
-                        break;
-                    case 'max':
-                        result[col] = nonNull.length > 0 ? Math.max(...nonNull.map(Number)) : null;
-                        break;
-                    case 'count':
-                        result[col] = nonNull.length;
-                        break;
-                    case 'first':
-                        result[col] = nonNull[0] ?? null;
-                        break;
-                    case 'last':
-                        result[col] = nonNull[nonNull.length - 1] ?? null;
-                        break;
-                }
-            }
-        });
-        return new DataFrame([result], { inferTypes: this._inferTypes });
-    }
-    /**
-     * Count rows
-     */
-    count() {
-        return this._height;
-    }
-    /**
-     * Sum of numeric column
-     */
-    sum(column) {
-        const values = this._data.get(column);
-        if (!values)
-            throw new Error(`Column '${column}' not found`);
-        return values.reduce((a, b) => a + (Number(b) || 0), 0);
-    }
-    /**
-     * Mean of numeric column
-     */
-    mean(column) {
-        const values = this._data.get(column);
-        if (!values)
-            throw new Error(`Column '${column}' not found`);
-        const nonNull = values.filter(v => v !== null && v !== undefined);
-        if (nonNull.length === 0)
-            return 0;
-        return nonNull.reduce((a, b) => a + Number(b), 0) / nonNull.length;
-    }
-    /**
-     * Min of column
-     */
-    min(column) {
-        const values = this._data.get(column);
-        if (!values)
-            throw new Error(`Column '${column}' not found`);
-        const nonNull = values.filter(v => v !== null && v !== undefined);
-        if (nonNull.length === 0)
-            return null;
-        return Math.min(...nonNull.map(Number));
-    }
-    /**
-     * Max of column
-     */
-    max(column) {
-        const values = this._data.get(column);
-        if (!values)
-            throw new Error(`Column '${column}' not found`);
-        const nonNull = values.filter(v => v !== null && v !== undefined);
-        if (nonNull.length === 0)
-            return null;
-        return Math.max(...nonNull.map(Number));
-    }
-    /* ═══════════════════════════════════════════════════
-     * JOINS & MERGING
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Merge with another DataFrame (SQL-like join)
-     */
-    merge(other, options = {}) {
-        const { on, leftOn = on, rightOn = on, how = 'inner', suffixes = ['_x', '_y'] } = options;
-        if (!leftOn || !rightOn) {
-            throw new Error('Must specify join columns with "on" or "leftOn"/"rightOn"');
-        }
-        const leftKeys = Array.isArray(leftOn) ? leftOn : [leftOn];
-        const rightKeys = Array.isArray(rightOn) ? rightOn : [rightOn];
-        // Build index on right DataFrame
-        const rightIndex = new Map();
-        other.toRows().forEach((row, i) => {
-            const key = rightKeys.map(k => JSON.stringify(row[k])).join('|');
-            if (!rightIndex.has(key))
-                rightIndex.set(key, []);
-            rightIndex.get(key).push(i);
-        });
-        const leftRows = this.toRows();
-        const rightRows = other.toRows();
-        const result = [];
-        // Determine output columns
-        const leftCols = this._columns;
-        const rightCols = other._columns.filter(c => !rightKeys.includes(c));
-        // Handle column name conflicts
-        const colMapping = {};
-        rightCols.forEach(c => {
-            if (leftCols.includes(c)) {
-                colMapping[c] = c + suffixes[1];
-            }
-            else {
-                colMapping[c] = c;
-            }
-        });
-        const matchedRight = new Set();
-        // Process left rows
-        leftRows.forEach(leftRow => {
-            const key = leftKeys.map(k => JSON.stringify(leftRow[k])).join('|');
-            const matches = rightIndex.get(key) || [];
-            if (matches.length > 0) {
-                matches.forEach(rightIdx => {
-                    matchedRight.add(rightIdx);
-                    const rightRow = rightRows[rightIdx];
-                    const merged = { ...leftRow };
-                    rightCols.forEach(c => {
-                        merged[colMapping[c]] = rightRow[c];
-                    });
-                    result.push(merged);
-                });
-            }
-            else if (how === 'left' || how === 'outer') {
-                const merged = { ...leftRow };
-                rightCols.forEach(c => {
-                    merged[colMapping[c]] = null;
-                });
-                result.push(merged);
-            }
-        });
-        // For right/outer joins, add unmatched right rows
-        if (how === 'right' || how === 'outer') {
-            rightRows.forEach((rightRow, i) => {
-                if (!matchedRight.has(i)) {
-                    const merged = {};
-                    leftCols.forEach(c => {
-                        merged[c] = null;
-                    });
-                    // Copy join keys from right
-                    rightKeys.forEach((rk, idx) => {
-                        merged[leftKeys[idx]] = rightRow[rk];
-                    });
-                    rightCols.forEach(c => {
-                        merged[colMapping[c]] = rightRow[c];
-                    });
-                    result.push(merged);
-                }
-            });
-        }
-        const outputCols = [
-            ...leftCols,
-            ...rightCols.map(c => colMapping[c])
-        ];
-        return new DataFrame(result, { columns: outputCols, inferTypes: this._inferTypes });
-    }
-    /**
-     * Concatenate DataFrames vertically (union)
-     */
-    concat(other, ignoreIndex = true) {
-        const others = Array.isArray(other) ? other : [other];
-        const allDfs = [this, ...others];
-        // Collect all unique columns
-        const allCols = new Set();
-        allDfs.forEach(df => df._columns.forEach(c => allCols.add(c)));
-        const columns = Array.from(allCols);
-        // Combine all rows
-        const rows = [];
-        allDfs.forEach(df => {
-            df.toRows().forEach(row => {
-                const newRow = {};
-                columns.forEach(c => {
-                    newRow[c] = row[c] ?? null;
-                });
-                rows.push(newRow);
-            });
-        });
-        return new DataFrame(rows, { columns, inferTypes: this._inferTypes });
-    }
-    /**
-     * Union (alias for concat)
-     */
-    union(other) {
-        return this.concat(other);
-    }
-    /* ═══════════════════════════════════════════════════
-     * TRANSFORMATION
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Apply function to each row
-     */
-    apply(fn) {
-        const rows = this.toRows().map((row, i) => fn(row, i));
-        return new DataFrame(rows, { inferTypes: this._inferTypes });
-    }
-    /**
-     * Map function over a column
-     */
-    map(column, fn) {
-        return this.withColumn(column, (row, i) => fn(row[column], i));
-    }
-    /**
-     * Pivot table
-     */
-    pivot(index, columns, values, aggFunc = 'first') {
-        const pivotValues = this.distinct(columns);
-        const indexValues = this.distinct(index);
-        const result = [];
-        indexValues.forEach(idxVal => {
-            const row = { [index]: idxVal };
-            pivotValues.forEach(pivotVal => {
-                const filtered = this
-                    .where(index, '==', idxVal)
-                    .where(columns, '==', pivotVal);
-                const vals = filtered.col(values).filter(v => v !== null && v !== undefined);
-                let aggValue = null;
-                if (vals.length > 0) {
-                    switch (aggFunc) {
-                        case 'sum':
-                            aggValue = vals.reduce((a, b) => a + Number(b), 0);
-                            break;
-                        case 'mean':
-                            aggValue = vals.reduce((a, b) => a + Number(b), 0) / vals.length;
-                            break;
-                        case 'count':
-                            aggValue = vals.length;
-                            break;
-                        case 'first':
-                            aggValue = vals[0];
-                            break;
-                    }
-                }
-                row[String(pivotVal)] = aggValue;
-            });
-            result.push(row);
-        });
-        return new DataFrame(result, { inferTypes: this._inferTypes });
-    }
-    /**
-     * Melt (unpivot) wide format to long format
-     */
-    melt(idVars, valueVars, varName = 'variable', valueName = 'value') {
-        const valueCols = valueVars || this._columns.filter(c => !idVars.includes(c));
-        const result = [];
-        this.toRows().forEach(row => {
-            valueCols.forEach(col => {
-                const newRow = {};
-                idVars.forEach(id => {
-                    newRow[id] = row[id];
-                });
-                newRow[varName] = col;
-                newRow[valueName] = row[col];
-                result.push(newRow);
-            });
-        });
-        return new DataFrame(result, { inferTypes: this._inferTypes });
-    }
-    /* ═══════════════════════════════════════════════════
-     * STATISTICS
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Describe numeric columns
-     */
-    describe() {
-        const stats = {};
-        this._columns.forEach(col => {
-            const values = this._data.get(col);
-            const numeric = values.filter(v => typeof v === 'number' && !isNaN(v));
-            if (numeric.length === 0) {
-                stats[col] = {
-                    count: values.filter(v => v !== null && v !== undefined).length,
-                    unique: new Set(values).size,
-                    dtype: this._schema.get(col)?.dtype || 'unknown'
-                };
-            }
-            else {
-                const sorted = [...numeric].sort((a, b) => a - b);
-                const sum = numeric.reduce((a, b) => a + b, 0);
-                const mean = sum / numeric.length;
-                const variance = numeric.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / numeric.length;
-                stats[col] = {
-                    count: numeric.length,
-                    mean: mean,
-                    std: Math.sqrt(variance),
-                    min: sorted[0],
-                    '25%': sorted[Math.floor(sorted.length * 0.25)],
-                    '50%': sorted[Math.floor(sorted.length * 0.5)],
-                    '75%': sorted[Math.floor(sorted.length * 0.75)],
-                    max: sorted[sorted.length - 1]
-                };
-            }
-        });
-        return stats;
-    }
-    /**
-     * Get info about DataFrame
-     */
-    info() {
-        const nullCounts = {};
-        let memoryEstimate = 0;
-        this._columns.forEach(col => {
-            const values = this._data.get(col);
-            nullCounts[col] = values.filter(v => v === null || v === undefined || v === '').length;
-            memoryEstimate += values.reduce((acc, v) => acc + (typeof v === 'string' ? v.length * 2 : 8), 0);
-        });
-        return {
-            rows: this._height,
-            columns: this._columns.length,
-            dtypes: this.dtypes,
-            nullCounts,
-            memoryEstimate
-        };
-    }
-    /* ═══════════════════════════════════════════════════
-     * EXPORT
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Convert to CSV string
-     */
-    toCSV(delimiter = ',') {
-        const escape = (val) => {
-            if (val === null || val === undefined)
-                return '';
-            const str = String(val);
-            if (str.includes(delimiter) || str.includes('"') || str.includes('\n')) {
-                return `"${str.replace(/"/g, '""')}"`;
-            }
-            return str;
-        };
-        const header = this._columns.map(escape).join(delimiter);
-        const rows = this.toRows().map(row => this._columns.map(col => escape(row[col])).join(delimiter));
-        return [header, ...rows].join('\n');
-    }
-    /**
-     * Convert to JSON string
-     */
-    toJSON(orient = 'records') {
-        switch (orient) {
-            case 'records':
-                return JSON.stringify(this.toRows());
-            case 'columns':
-                return JSON.stringify(this.toColumns());
-            case 'split':
-                return JSON.stringify({
-                    columns: this._columns,
-                    data: this.toRows().map(row => this._columns.map(c => row[c]))
-                });
-            default:
-                return JSON.stringify(this.toRows());
-        }
-    }
-    /**
-     * Clone the DataFrame
-     */
-    clone() {
-        return new DataFrame(this);
-    }
-    /**
-     * Print preview (for debugging)
-     */
-    print(n = 10) {
-        console.log(`DataFrame: ${this._height} rows × ${this._columns.length} columns`);
-        console.log('Columns:', this._columns.join(', '));
-        console.table(this.head(n).toRows());
-    }
-}
-/**
- * GroupedDataFrame for group-by operations
- */
-export class GroupedDataFrame {
-    constructor(df, groupCols) {
-        this._df = df;
-        this._groupCols = groupCols;
-        this._groups = new Map();
-        // Build groups
-        df.toRows().forEach((row, i) => {
-            const key = groupCols.map(c => JSON.stringify(row[c])).join('|');
-            if (!this._groups.has(key))
-                this._groups.set(key, []);
-            this._groups.get(key).push(i);
-        });
-    }
-    /**
-     * Aggregate groups
-     */
-    agg(aggregations) {
-        const result = [];
-        const allRows = this._df.toRows();
-        this._groups.forEach((indices, key) => {
-            const groupRows = indices.map(i => allRows[i]);
-            const row = {};
-            // Add group columns
-            this._groupCols.forEach(c => {
-                row[c] = groupRows[0][c];
-            });
-            // Add aggregated values
-            Object.entries(aggregations).forEach(([col, aggFn]) => {
-                const values = groupRows.map(r => r[col]).filter(v => v !== null && v !== undefined);
-                if (typeof aggFn === 'function') {
-                    row[col] = aggFn(values);
-                }
-                else {
-                    switch (aggFn) {
-                        case 'sum':
-                            row[col] = values.reduce((a, b) => a + Number(b), 0);
-                            break;
-                        case 'mean':
-                            row[col] = values.length > 0
-                                ? values.reduce((a, b) => a + Number(b), 0) / values.length
-                                : null;
-                            break;
-                        case 'min':
-                            row[col] = values.length > 0 ? Math.min(...values.map(Number)) : null;
-                            break;
-                        case 'max':
-                            row[col] = values.length > 0 ? Math.max(...values.map(Number)) : null;
-                            break;
-                        case 'count':
-                            row[col] = values.length;
-                            break;
-                        case 'first':
-                            row[col] = values[0] ?? null;
-                            break;
-                        case 'last':
-                            row[col] = values[values.length - 1] ?? null;
-                            break;
-                    }
-                }
-            });
-            result.push(row);
-        });
-        return new DataFrame(result);
-    }
-    /**
-     * Count per group
-     */
-    count() {
-        return this.agg({ _count: 'count' }).rename({ _count: 'count' });
-    }
-    /**
-     * Sum per group
-     */
-    sum(column) {
-        return this.agg({ [column]: 'sum' });
-    }
-    /**
-     * Mean per group
-     */
-    mean(column) {
-        return this.agg({ [column]: 'mean' });
-    }
-    /**
-     * Get number of groups
-     */
-    get ngroups() {
-        return this._groups.size;
-    }
-    /**
-     * Get group keys
-     */
-    get groups() {
-        return Array.from(this._groups.keys());
-    }
-}