jtcsv 2.2.7 → 3.0.0

package/dist/jtcsv-full.cjs.js

@@ -0,0 +1,1912 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// Система ошибок для браузерной версии jtcsv
+// Адаптирована для работы без Node.js специфичных API
+/**
+ * Базовый класс ошибки jtcsv
+ */
+class JTCSVError extends Error {
+    constructor(message, code = 'JTCSV_ERROR', details = {}) {
+        super(message);
+        this.name = 'JTCSVError';
+        this.code = code;
+        this.details = details;
+        // Сохранение stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, JTCSVError);
+        }
+    }
+}
+/**
+ * Ошибка валидации
+ */
+class ValidationError extends JTCSVError {
+    constructor(message, details = {}) {
+        super(message, 'VALIDATION_ERROR', details);
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Ошибка безопасности
+ */
+class SecurityError extends JTCSVError {
+    constructor(message, details = {}) {
+        super(message, 'SECURITY_ERROR', details);
+        this.name = 'SecurityError';
+    }
+}
+/**
+ * Ошибка файловой системы (адаптирована для браузера)
+ */
+class FileSystemError extends JTCSVError {
+    constructor(message, originalError, details = {}) {
+        super(message, 'FILE_SYSTEM_ERROR', { ...details, originalError });
+        this.name = 'FileSystemError';
+        if (originalError && originalError.code) {
+            this.code = originalError.code;
+        }
+    }
+}
+/**
+ * Ошибка парсинга
+ */
+class ParsingError extends JTCSVError {
+    constructor(message, lineNumber, details = {}) {
+        super(message, 'PARSING_ERROR', { ...details, lineNumber });
+        this.name = 'ParsingError';
+        this.lineNumber = lineNumber;
+    }
+}
+/**
+ * Ошибка превышения лимита
+ */
+class LimitError extends JTCSVError {
+    constructor(message, limit, actual, details = {}) {
+        super(message, 'LIMIT_ERROR', { ...details, limit, actual });
+        this.name = 'LimitError';
+        this.limit = limit;
+        this.actual = actual;
+    }
+}
+/**
+ * Ошибка конфигурации
+ */
+class ConfigurationError extends JTCSVError {
+    constructor(message, details = {}) {
+        super(message, 'CONFIGURATION_ERROR', details);
+        this.name = 'ConfigurationError';
+    }
+}
+/**
+ * Коды ошибок
+ */
+const ERROR_CODES = {
+    JTCSV_ERROR: 'JTCSV_ERROR',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    SECURITY_ERROR: 'SECURITY_ERROR',
+    FILE_SYSTEM_ERROR: 'FILE_SYSTEM_ERROR',
+    PARSING_ERROR: 'PARSING_ERROR',
+    LIMIT_ERROR: 'LIMIT_ERROR',
+    CONFIGURATION_ERROR: 'CONFIGURATION_ERROR',
+    INVALID_INPUT: 'INVALID_INPUT',
+    SECURITY_VIOLATION: 'SECURITY_VIOLATION',
+    FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+    PARSE_FAILED: 'PARSE_FAILED',
+    SIZE_LIMIT: 'SIZE_LIMIT',
+    INVALID_CONFIG: 'INVALID_CONFIG',
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+};
+/**
+ * Безопасное выполнение функции с обработкой ошибок
+ *
+ * @param fn - Функция для выполнения
+ * @param errorCode - Код ошибки по умолчанию
+ * @param errorDetails - Детали ошибки
+ * @returns Результат выполнения функции
+ */
+function safeExecute(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
+    try {
+        if (typeof fn === 'function') {
+            return fn();
+        }
+        throw new ValidationError('Function expected');
+    }
+    catch (error) {
+        // Если ошибка уже является JTCSVError, перебросить её
+        if (error instanceof JTCSVError) {
+            throw error;
+        }
+        // Определить тип ошибки на основе сообщения или кода
+        let enhancedError;
+        const errorMessage = error.message || String(error);
+        if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
+            enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
+            enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
+            enhancedError = new ParsingError(errorMessage, undefined, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
+            enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
+            enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('file') || errorMessage.includes('File')) {
+            enhancedError = new FileSystemError(errorMessage, error, errorDetails);
+        }
+        else {
+            // Общая ошибка
+            enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error });
+        }
+        // Сохранить оригинальный stack trace если возможно
+        if (error.stack) {
+            enhancedError.stack = error.stack;
+        }
+        throw enhancedError;
+    }
+}
+/**
+ * Асинхронная версия safeExecute
+ */
+async function safeExecuteAsync(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
+    try {
+        if (typeof fn === 'function') {
+            return await fn();
+        }
+        throw new ValidationError('Function expected');
+    }
+    catch (error) {
+        // Если ошибка уже является JTCSVError, перебросить её
+        if (error instanceof JTCSVError) {
+            throw error;
+        }
+        // Определить тип ошибки
+        let enhancedError;
+        const errorMessage = error.message || String(error);
+        if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
+            enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
+            enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
+            enhancedError = new ParsingError(errorMessage, undefined, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
+            enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
+            enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('file') || errorMessage.includes('File')) {
+            enhancedError = new FileSystemError(errorMessage, error, errorDetails);
+        }
+        else {
+            enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error });
+        }
+        if (error.stack) {
+            enhancedError.stack = error.stack;
+        }
+        throw enhancedError;
+    }
+}
+/**
+ * Создать сообщение об ошибке
+ */
+function createErrorMessage(error, includeStack = false) {
+    let message = error.message || 'Unknown error';
+    if (error instanceof JTCSVError) {
+        message = `[${error.code}] ${message}`;
+        if (error instanceof ParsingError && error.lineNumber) {
+            message += ` (line ${error.lineNumber})`;
+        }
+        if (error instanceof LimitError && error.limit && error.actual) {
+            message += ` (limit: ${error.limit}, actual: ${error.actual})`;
+        }
+    }
+    if (includeStack && error.stack) {
+        message += `\n${error.stack}`;
+    }
+    return message;
+}
+/**
+ * Обработка ошибки
+ */
+function handleError(error, options = {}) {
+    const { log = true, throw: shouldThrow = false, format = true } = options;
+    const message = format ? createErrorMessage(error) : error.message;
+    if (log) {
+        console.error(`[jtcsv] ${message}`);
+        if (error instanceof JTCSVError && error.details) {
+            console.error('Error details:', error.details);
+        }
+    }
+    if (shouldThrow) {
+        throw error;
+    }
+    return message;
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        JTCSVError,
+        ValidationError,
+        SecurityError,
+        FileSystemError,
+        ParsingError,
+        LimitError,
+        ConfigurationError,
+        ERROR_CODES,
+        safeExecute,
+        safeExecuteAsync,
+        createErrorMessage,
+        handleError
+    };
+}
+
+// Браузерная версия JSON to CSV конвертера
+// Адаптирована для работы в браузере без Node.js API
+/**
+ * Валидация входных данных и опций
+ * @private
+ */
+function validateInput(data, options) {
+    // Validate data
+    if (!Array.isArray(data)) {
+        throw new ValidationError('Input data must be an array');
+    }
+    // Validate options
+    if (options && typeof options !== 'object') {
+        throw new ConfigurationError('Options must be an object');
+    }
+    // Validate delimiter
+    if (options?.delimiter && typeof options.delimiter !== 'string') {
+        throw new ConfigurationError('Delimiter must be a string');
+    }
+    if (options?.delimiter && options.delimiter.length !== 1) {
+        throw new ConfigurationError('Delimiter must be a single character');
+    }
+    // Validate renameMap
+    if (options?.renameMap && typeof options.renameMap !== 'object') {
+        throw new ConfigurationError('renameMap must be an object');
+    }
+    // Validate maxRecords
+    if (options && options.maxRecords !== undefined) {
+        if (typeof options.maxRecords !== 'number' || options.maxRecords <= 0) {
+            throw new ConfigurationError('maxRecords must be a positive number');
+        }
+    }
+    // Validate preventCsvInjection
+    if (options?.preventCsvInjection !== undefined && typeof options.preventCsvInjection !== 'boolean') {
+        throw new ConfigurationError('preventCsvInjection must be a boolean');
+    }
+    // Validate rfc4180Compliant
+    if (options?.rfc4180Compliant !== undefined && typeof options.rfc4180Compliant !== 'boolean') {
+        throw new ConfigurationError('rfc4180Compliant must be a boolean');
+    }
+    return true;
+}
+/**
+ * Экранирование CSV значений для предотвращения инъекций
+ * @private
+ */
+function escapeCsvValue(value, preventInjection = true) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    const str = String(value);
+    // Экранирование формул для предотвращения CSV инъекций
+    if (preventInjection && /^[=+\-@]/.test(str)) {
+        return "'" + str;
+    }
+    // Экранирование кавычек и переносов строк
+    if (str.includes('"') || str.includes('\n') || str.includes('\r') || str.includes(',')) {
+        return '"' + str.replace(/"/g, '""') + '"';
+    }
+    return str;
+}
+/**
+ * Извлечение всех уникальных ключей из массива объектов
+ * @private
+ */
+function extractAllKeys(data) {
+    const keys = new Set();
+    for (const item of data) {
+        if (item && typeof item === 'object') {
+            Object.keys(item).forEach(key => keys.add(key));
+        }
+    }
+    return Array.from(keys);
+}
+/**
+ * Конвертация массива объектов в CSV строку
+ *
+ * @param data - Массив объектов для конвертации
+ * @param options - Опции конвертации
+ * @returns CSV строка
+ */
+function jsonToCsv$1(data, options = {}) {
+    return safeExecute(() => {
+        validateInput(data, options);
+        if (data.length === 0) {
+            return '';
+        }
+        // Настройки по умолчанию
+        const delimiter = options.delimiter || ';';
+        const includeHeaders = options.includeHeaders !== false;
+        const maxRecords = options.maxRecords || data.length;
+        const preventInjection = options.preventCsvInjection !== false;
+        const rfc4180Compliant = options.rfc4180Compliant !== false;
+        // Ограничение количества записей
+        const limitedData = data.slice(0, maxRecords);
+        // Извлечение всех ключей
+        const allKeys = extractAllKeys(limitedData);
+        // Применение renameMap если есть
+        const renameMap = options.renameMap || {};
+        const finalKeys = allKeys.map(key => renameMap[key] || key);
+        // Создание CSV строки
+        const lines = [];
+        // Заголовки
+        if (includeHeaders) {
+            const headerLine = finalKeys.map(key => escapeCsvValue(key, preventInjection)).join(delimiter);
+            lines.push(headerLine);
+        }
+        // Данные
+        for (const item of limitedData) {
+            const rowValues = allKeys.map(key => {
+                const value = item?.[key];
+                return escapeCsvValue(value, preventInjection);
+            });
+            lines.push(rowValues.join(delimiter));
+        }
+        // RFC 4180 compliance: CRLF line endings
+        if (rfc4180Compliant) {
+            return lines.join('\r\n');
+        }
+        return lines.join('\n');
+    });
+}
+/**
+ * Асинхронная версия jsonToCsv
+ */
+async function jsonToCsvAsync$1(data, options = {}) {
+    return jsonToCsv$1(data, options);
+}
+/**
+ * Создает итератор для потоковой конвертации JSON в CSV
+ *
+ * @param data - Массив объектов или async итератор
+ * @param options - Опции конвертации
+ * @returns AsyncIterator с CSV чанками
+ */
+async function* jsonToCsvIterator(data, options = {}) {
+    validateInput(Array.isArray(data) ? data : [], options);
+    const delimiter = options.delimiter || ';';
+    const includeHeaders = options.includeHeaders !== false;
+    const preventInjection = options.preventCsvInjection !== false;
+    const rfc4180Compliant = options.rfc4180Compliant !== false;
+    let allKeys = [];
+    let renameMap = {};
+    // Если данные - массив, обрабатываем как массив
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            return;
+        }
+        allKeys = extractAllKeys(data);
+        renameMap = options.renameMap || {};
+        const finalKeys = allKeys.map(key => renameMap[key] || key);
+        // Заголовки
+        if (includeHeaders) {
+            const headerLine = finalKeys.map(key => escapeCsvValue(key, preventInjection)).join(delimiter);
+            yield headerLine + (rfc4180Compliant ? '\r\n' : '\n');
+        }
+        // Данные
+        for (const item of data) {
+            const rowValues = allKeys.map(key => {
+                const value = item?.[key];
+                return escapeCsvValue(value, preventInjection);
+            });
+            yield rowValues.join(delimiter) + (rfc4180Compliant ? '\r\n' : '\n');
+        }
+    }
+    else {
+        // Для async итератора нужна другая логика
+        throw new ValidationError('Async iterators not yet implemented in browser version');
+    }
+}
+/**
+ * Асинхронная версия jsonToCsvIterator (псевдоним)
+ */
+const jsonToCsvIteratorAsync = jsonToCsvIterator;
+/**
+ * Безопасная конвертация с обработкой ошибок
+ *
+ * @param data - Массив объектов
+ * @param options - Опции конвертации
+ * @returns CSV строка или null при ошибке
+ */
+function jsonToCsvSafe(data, options = {}) {
+    try {
+        return jsonToCsv$1(data, options);
+    }
+    catch (error) {
+        console.error('JSON to CSV conversion error:', error);
+        return null;
+    }
+}
+/**
+ * Асинхронная версия jsonToCsvSafe
+ */
+async function jsonToCsvSafeAsync(data, options = {}) {
+    try {
+        return await jsonToCsvAsync$1(data, options);
+    }
+    catch (error) {
+        console.error('JSON to CSV conversion error:', error);
+        return null;
+    }
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        jsonToCsv: jsonToCsv$1,
+        jsonToCsvAsync: jsonToCsvAsync$1,
+        jsonToCsvIterator,
+        jsonToCsvIteratorAsync,
+        jsonToCsvSafe,
+        jsonToCsvSafeAsync
+    };
+}
+
+var jsonToCsvBrowser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    jsonToCsv: jsonToCsv$1,
+    jsonToCsvAsync: jsonToCsvAsync$1,
+    jsonToCsvIterator: jsonToCsvIterator,
+    jsonToCsvIteratorAsync: jsonToCsvIteratorAsync,
+    jsonToCsvSafe: jsonToCsvSafe,
+    jsonToCsvSafeAsync: jsonToCsvSafeAsync
+});
+
+// Браузерная версия CSV to JSON конвертера
+// Адаптирована для работы в браузере без Node.js API
+/**
+ * Валидация опций парсинга
+ * @private
+ */
+function validateCsvOptions(options) {
+    // Validate options
+    if (options && typeof options !== 'object') {
+        throw new ConfigurationError('Options must be an object');
+    }
+    // Validate delimiter
+    if (options?.delimiter && typeof options.delimiter !== 'string') {
+        throw new ConfigurationError('Delimiter must be a string');
+    }
+    if (options?.delimiter && options.delimiter.length !== 1) {
+        throw new ConfigurationError('Delimiter must be a single character');
+    }
+    // Validate autoDetect
+    if (options?.autoDetect !== undefined && typeof options.autoDetect !== 'boolean') {
+        throw new ConfigurationError('autoDetect must be a boolean');
+    }
+    // Validate candidates
+    if (options?.candidates && !Array.isArray(options.candidates)) {
+        throw new ConfigurationError('candidates must be an array');
+    }
+    // Validate maxRows
+    if (options?.maxRows !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
+        throw new ConfigurationError('maxRows must be a positive number');
+    }
+    if (options?.warnExtraFields !== undefined && typeof options.warnExtraFields !== 'boolean') {
+        throw new ConfigurationError('warnExtraFields must be a boolean');
+    }
+    return true;
+}
+/**
+ * Автоматическое определение разделителя
+ * @private
+ */
+function autoDetectDelimiter$1(text, candidates = [',', ';', '\t', '|']) {
+    if (!text || typeof text !== 'string') {
+        return ',';
+    }
+    const firstLine = text.split('\n')[0];
+    if (!firstLine) {
+        return ',';
+    }
+    let bestCandidate = ',';
+    let bestCount = 0;
+    for (const candidate of candidates) {
+        const count = (firstLine.match(new RegExp(candidate.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
+        if (count > bestCount) {
+            bestCount = count;
+            bestCandidate = candidate;
+        }
+    }
+    return bestCandidate;
+}
+/**
+ * Парсинг CSV строки в массив объектов
+ *
+ * @param csvText - CSV текст для парсинга
+ * @param options - Опции парсинга
+ * @returns Массив объектов
+ */
+function csvToJson$1(csvText, options = {}) {
+    return safeExecute(() => {
+        validateCsvOptions(options);
+        if (typeof csvText !== 'string') {
+            throw new ValidationError('CSV text must be a string');
+        }
+        if (csvText.trim() === '') {
+            return [];
+        }
+        // Определение разделителя
+        const delimiter = options.delimiter ||
+            (options.autoDetect !== false ? autoDetectDelimiter$1(csvText, options.candidates) : ',');
+        // Разделение на строки
+        const lines = csvText.split('\n').filter(line => line.trim() !== '');
+        if (lines.length === 0) {
+            return [];
+        }
+        // Парсинг заголовков
+        const headers = lines[0].split(delimiter).map(h => h.trim());
+        // Ограничение количества строк
+        const maxRows = options.maxRows || Infinity;
+        const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
+        // Парсинг данных
+        const result = [];
+        for (let i = 0; i < dataRows.length; i++) {
+            const line = dataRows[i];
+            const values = line.split(delimiter);
+            const row = {};
+            for (let j = 0; j < headers.length; j++) {
+                const header = headers[j];
+                const value = j < values.length ? values[j].trim() : '';
+                // Попытка парсинга чисел
+                if (/^-?\d+(\.\d+)?$/.test(value)) {
+                    row[header] = parseFloat(value);
+                }
+                else if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
+                    row[header] = value.toLowerCase() === 'true';
+                }
+                else {
+                    row[header] = value;
+                }
+            }
+            result.push(row);
+        }
+        return result;
+    });
+}
+/**
+ * Асинхронная версия csvToJson
+ */
+async function csvToJsonAsync$1(csvText, options = {}) {
+    return csvToJson$1(csvText, options);
+}
+/**
+ * Создает итератор для потокового парсинга CSV
+ *
+ * @param input - CSV текст, File или Blob
+ * @param options - Опции парсинга
+ * @returns AsyncGenerator
+ */
+async function* csvToJsonIterator$1(input, options = {}) {
+    validateCsvOptions(options);
+    let csvText;
+    if (typeof input === 'string') {
+        csvText = input;
+    }
+    else if (input instanceof File || input instanceof Blob) {
+        csvText = await input.text();
+    }
+    else {
+        throw new ValidationError('Input must be string, File or Blob');
+    }
+    if (csvText.trim() === '') {
+        return;
+    }
+    // Определение разделителя
+    const delimiter = options.delimiter ||
+        (options.autoDetect !== false ? autoDetectDelimiter$1(csvText, options.candidates) : ',');
+    // Разделение на строки
+    const lines = csvText.split('\n').filter(line => line.trim() !== '');
+    if (lines.length === 0) {
+        return;
+    }
+    // Парсинг заголовков
+    const headers = lines[0].split(delimiter).map(h => h.trim());
+    // Ограничение количества строк
+    const maxRows = options.maxRows || Infinity;
+    const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
+    // Возврат данных по одной строке
+    for (let i = 0; i < dataRows.length; i++) {
+        const line = dataRows[i];
+        const values = line.split(delimiter);
+        const row = {};
+        for (let j = 0; j < headers.length; j++) {
+            const header = headers[j];
+            const value = j < values.length ? values[j].trim() : '';
+            // Попытка парсинга чисел
+            if (/^-?\d+(\.\d+)?$/.test(value)) {
+                row[header] = parseFloat(value);
+            }
+            else if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
+                row[header] = value.toLowerCase() === 'true';
+            }
+            else {
+                row[header] = value;
+            }
+        }
+        yield row;
+    }
+}
+/**
+ * Асинхронная версия csvToJsonIterator (псевдоним)
+ */
+const csvToJsonIteratorAsync = csvToJsonIterator$1;
+/**
+ * Парсинг CSV с обработкой ошибок
+ *
+ * @param csvText - CSV текст
+ * @param options - Опции парсинга
+ * @returns Результат парсинга или null при ошибке
+ */
+function parseCsvSafe(csvText, options = {}) {
+    try {
+        return csvToJson$1(csvText, options);
+    }
+    catch (error) {
+        console.error('CSV parsing error:', error);
+        return null;
+    }
+}
+/**
+ * Асинхронная версия parseCsvSafe
+ */
+async function parseCsvSafeAsync(csvText, options = {}) {
+    try {
+        return await csvToJsonAsync$1(csvText, options);
+    }
+    catch (error) {
+        console.error('CSV parsing error:', error);
+        return null;
+    }
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        csvToJson: csvToJson$1,
+        csvToJsonAsync: csvToJsonAsync$1,
+        csvToJsonIterator: csvToJsonIterator$1,
+        csvToJsonIteratorAsync,
+        parseCsvSafe,
+        parseCsvSafeAsync,
+        autoDetectDelimiter: autoDetectDelimiter$1
+    };
+}
+
+var csvToJsonBrowser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    csvToJson: csvToJson$1,
+    csvToJsonAsync: csvToJsonAsync$1,
+    csvToJsonIterator: csvToJsonIterator$1,
+    csvToJsonIteratorAsync: csvToJsonIteratorAsync,
+    parseCsvSafe: parseCsvSafe,
+    parseCsvSafeAsync: parseCsvSafeAsync
+});
+
+function isReadableStream(value) {
+    return value && typeof value.getReader === 'function';
+}
+function isAsyncIterable(value) {
+    return value && typeof value[Symbol.asyncIterator] === 'function';
+}
+function isIterable(value) {
+    return value && typeof value[Symbol.iterator] === 'function';
+}
+function createReadableStreamFromIterator(iterator) {
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const { value, done } = await iterator.next();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        cancel() {
+            if (iterator.return) {
+                iterator.return();
+            }
+        }
+    });
+}
+function detectInputFormat(input, options) {
+    if (options && options.inputFormat) {
+        return options.inputFormat;
+    }
+    if (typeof input === 'string') {
+        const trimmed = input.trim();
+        if (trimmed === '') {
+            return 'unknown';
+        }
+        // Проверка на NDJSON (каждая строка - валидный JSON)
+        if (trimmed.includes('\n')) {
+            const lines = trimmed.split('\n').filter(line => line.trim() !== '');
+            if (lines.length > 0) {
+                try {
+                    JSON.parse(lines[0]);
+                    return 'ndjson';
+                }
+                catch {
+                    // Не NDJSON
+                }
+            }
+        }
+        // Проверка на JSON
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed) || (parsed && typeof parsed === 'object')) {
+                return 'json';
+            }
+        }
+        catch {
+            // Не JSON
+        }
+        // Проверка на CSV
+        if (trimmed.includes(',') || trimmed.includes(';') || trimmed.includes('\t')) {
+            return 'csv';
+        }
+    }
+    return 'unknown';
+}
+async function* jsonToCsvChunkIterator(input, options = {}) {
+    const format = detectInputFormat(input, options);
+    if (format === 'csv') {
+        throw new ValidationError('Input appears to be CSV, not JSON');
+    }
+    // Вспомогательная функция для создания асинхронного итератора
+    function toAsyncIterator(iterable) {
+        if (isAsyncIterable(iterable)) {
+            return iterable[Symbol.asyncIterator]();
+        }
+        if (isIterable(iterable)) {
+            const syncIterator = iterable[Symbol.iterator]();
+            return {
+                next: () => Promise.resolve(syncIterator.next()),
+                return: syncIterator.return ? () => Promise.resolve(syncIterator.return()) : undefined,
+                throw: syncIterator.throw ? (error) => Promise.resolve(syncIterator.throw(error)) : undefined
+            };
+        }
+        throw new ValidationError('Input is not iterable');
+    }
+    let iterator;
+    if (isAsyncIterable(input) || isIterable(input)) {
+        iterator = toAsyncIterator(input);
+    }
+    else if (typeof input === 'string') {
+        const parsed = JSON.parse(input);
+        if (Array.isArray(parsed)) {
+            iterator = toAsyncIterator(parsed);
+        }
+        else {
+            iterator = toAsyncIterator([parsed]);
+        }
+    }
+    else if (Array.isArray(input)) {
+        iterator = toAsyncIterator(input);
+    }
+    else {
+        iterator = toAsyncIterator([input]);
+    }
+    const delimiter = options.delimiter || ';';
+    const includeHeaders = options.includeHeaders !== false;
+    const preventInjection = options.preventCsvInjection !== false;
+    let isFirstChunk = true;
+    let headers = [];
+    while (true) {
+        const { value, done } = await iterator.next();
+        if (done)
+            break;
+        const item = value;
+        if (isFirstChunk) {
+            // Извлечение заголовков из первого элемента
+            headers = Object.keys(item);
+            if (includeHeaders) {
+                const headerLine = headers.map(header => {
+                    const escaped = header.includes('"') ? `"${header.replace(/"/g, '""')}"` : header;
+                    return preventInjection && /^[=+\-@]/.test(escaped) ? `'${escaped}` : escaped;
+                }).join(delimiter);
+                yield headerLine + '\n';
+            }
+            isFirstChunk = false;
+        }
+        const row = headers.map(header => {
+            const value = item[header];
+            const strValue = value === null || value === undefined ? '' : String(value);
+            if (strValue.includes('"') || strValue.includes('\n') || strValue.includes('\r') || strValue.includes(delimiter)) {
+                return `"${strValue.replace(/"/g, '""')}"`;
+            }
+            if (preventInjection && /^[=+\-@]/.test(strValue)) {
+                return `'${strValue}`;
+            }
+            return strValue;
+        }).join(delimiter);
+        yield row + '\n';
+    }
+}
+async function* jsonToNdjsonChunkIterator(input, options = {}) {
+    const format = detectInputFormat(input, options);
+    // Вспомогательная функция для создания асинхронного итератора
+    function toAsyncIterator(iterable) {
+        if (isAsyncIterable(iterable)) {
+            return iterable[Symbol.asyncIterator]();
+        }
+        if (isIterable(iterable)) {
+            const syncIterator = iterable[Symbol.iterator]();
+            return {
+                next: () => Promise.resolve(syncIterator.next()),
+                return: syncIterator.return ? () => Promise.resolve(syncIterator.return()) : undefined,
+                throw: syncIterator.throw ? (error) => Promise.resolve(syncIterator.throw(error)) : undefined
+            };
+        }
+        throw new ValidationError('Input is not iterable');
+    }
+    let iterator;
+    if (isAsyncIterable(input) || isIterable(input)) {
+        iterator = toAsyncIterator(input);
+    }
+    else if (typeof input === 'string') {
+        if (format === 'ndjson') {
+            const lines = input.split('\n').filter(line => line.trim() !== '');
+            iterator = toAsyncIterator(lines);
+        }
+        else {
+            const parsed = JSON.parse(input);
+            if (Array.isArray(parsed)) {
+                iterator = toAsyncIterator(parsed);
+            }
+            else {
+                iterator = toAsyncIterator([parsed]);
+            }
+        }
+    }
+    else if (Array.isArray(input)) {
+        iterator = toAsyncIterator(input);
+    }
+    else {
+        iterator = toAsyncIterator([input]);
+    }
+    while (true) {
+        const { value, done } = await iterator.next();
+        if (done)
+            break;
+        let jsonStr;
+        if (typeof value === 'string') {
+            try {
+                // Проверяем, является ли строка валидным JSON
+                JSON.parse(value);
+                jsonStr = value;
+            }
+            catch {
+                // Если нет, сериализуем как JSON
+                jsonStr = JSON.stringify(value);
+            }
+        }
+        else {
+            jsonStr = JSON.stringify(value);
+        }
+        yield jsonStr + '\n';
+    }
+}
+async function* csvToJsonChunkIterator(input, options = {}) {
+    if (typeof input === 'string') {
+        // Используем csvToJsonIterator из csv-to-json-browser
+        yield* csvToJsonIterator$1(input, options);
+    }
+    else if (input instanceof File || input instanceof Blob) {
+        const text = await input.text();
+        yield* csvToJsonIterator$1(text, options);
+    }
+    else if (isReadableStream(input)) {
+        const reader = input.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Обработка буфера по строкам
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                // TODO: Реализовать парсинг CSV из чанков
+                // Пока просто возвращаем сырые строки
+                for (const line of lines) {
+                    if (line.trim()) {
+                        yield { raw: line };
+                    }
+                }
+            }
+            // Обработка остатка буфера
+            if (buffer.trim()) {
+                yield { raw: buffer };
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    else {
+        throw new ValidationError('Unsupported input type for CSV streaming');
+    }
+}
+function jsonToCsvStream$1(input, options = {}) {
+    const iterator = jsonToCsvChunkIterator(input, options);
+    return createReadableStreamFromIterator(iterator);
+}
+function jsonToNdjsonStream$1(input, options = {}) {
+    const iterator = jsonToNdjsonChunkIterator(input, options);
+    return createReadableStreamFromIterator(iterator);
+}
+function csvToJsonStream$1(input, options = {}) {
+    const iterator = csvToJsonChunkIterator(input, options);
+    return createReadableStreamFromIterator(iterator);
+}
+/**
+ * Асинхронная версия jsonToCsvStream
+ */
+async function jsonToCsvStreamAsync(input, options = {}) {
+    return jsonToCsvStream$1(input, options);
+}
+/**
+ * Асинхронная версия jsonToNdjsonStream
+ */
+async function jsonToNdjsonStreamAsync(input, options = {}) {
+    return jsonToNdjsonStream$1(input, options);
+}
+/**
+ * Асинхронная версия csvToJsonStream
+ */
+async function csvToJsonStreamAsync(input, options = {}) {
+    return csvToJsonStream$1(input, options);
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        jsonToCsvStream: jsonToCsvStream$1,
+        jsonToCsvStreamAsync,
+        jsonToNdjsonStream: jsonToNdjsonStream$1,
+        jsonToNdjsonStreamAsync,
+        csvToJsonStream: csvToJsonStream$1,
+        csvToJsonStreamAsync,
+        createReadableStreamFromIterator
+    };
+}
+
+// Браузерные специфичные функции для jtcsv
+// Функции, которые работают только в браузере
+/**
+ * Скачивает JSON данные как CSV файл
+ *
+ * @param data - Массив объектов для конвертации
+ * @param filename - Имя файла для скачивания (по умолчанию 'data.csv')
+ * @param options - Опции для jsonToCsv
+ *
+ * @example
+ * const data = [
+ *   { id: 1, name: 'John' },
+ *   { id: 2, name: 'Jane' }
+ * ];
+ * downloadAsCsv(data, 'users.csv', { delimiter: ',' });
+ */
+function downloadAsCsv(data, filename = 'data.csv', options = {}) {
+    // Проверка что мы в браузере
+    if (typeof window === 'undefined') {
+        throw new ValidationError('downloadAsCsv() работает только в браузере. Используйте saveAsCsv() в Node.js');
+    }
+    // Валидация имени файла
+    if (typeof filename !== 'string' || filename.trim() === '') {
+        throw new ValidationError('Filename must be a non-empty string');
+    }
+    // Добавление расширения .csv если его нет
+    if (!filename.toLowerCase().endsWith('.csv')) {
+        filename += '.csv';
+    }
+    // Конвертация в CSV
+    const csv = jsonToCsv$1(data, options);
+    // Создание Blob
+    const blob = new Blob([csv], {
+        type: 'text/csv;charset=utf-8;'
+    });
+    // Создание ссылки для скачивания
+    const link = document.createElement('a');
+    const url = URL.createObjectURL(blob);
+    link.setAttribute('href', url);
+    link.setAttribute('download', filename);
+    link.style.visibility = 'hidden';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    // Освобождение URL
+    setTimeout(() => URL.revokeObjectURL(url), 100);
+}
+/**
+ * Асинхронная версия downloadAsCsv
+ */
+async function downloadAsCsvAsync$1(data, filename = 'data.csv', options = {}) {
+    return downloadAsCsv(data, filename, options);
+}
+/**
+ * Парсит CSV файл из input[type="file"]
+ *
+ * @param file - File объект из input
+ * @param options - Опции для csvToJson
+ * @returns Promise с распарсенными данными
+ */
+async function parseCsvFile(file, options = {}) {
+    if (!(file instanceof File)) {
+        throw new ValidationError('parseCsvFile() ожидает объект File');
+    }
+    // Чтение файла как текст
+    const text = await file.text();
+    // Парсинг CSV
+    return csvToJson$1(text, options);
+}
+/**
+ * Парсит CSV файл потоково
+ *
+ * @param file - File объект
+ * @param options - Опции для потокового парсинга
+ * @returns AsyncIterator с данными
+ */
+function parseCsvFileStream(file, options = {}) {
+    if (!(file instanceof File)) {
+        throw new ValidationError('parseCsvFileStream() ожидает объект File');
+    }
+    // Используем csvToJsonIterator из импортированного модуля
+    return csvToJsonIterator$1(file, options);
+}
+/**
+ * Создает поток для конвертации JSON в CSV
+ *
+ * @param options - Опции для jsonToCsv
+ * @returns ReadableStream
+ */
+function jsonToCsvStream(options = {}) {
+    return jsonToCsvStream$1(options);
+}
+/**
+ * Создает поток для конвертации JSON в NDJSON
+ *
+ * @param options - Опции для конвертации
+ * @returns ReadableStream
+ */
+function jsonToNdjsonStream(options = {}) {
+    return jsonToNdjsonStream$1(options);
+}
+/**
+ * Создает поток для парсинга CSV в JSON
+ *
+ * @param options - Опции для csvToJson
+ * @returns ReadableStream
+ */
+function csvToJsonStream(options = {}) {
+    return csvToJsonStream$1(options);
+}
+/**
+ * Загружает CSV файл по URL
+ *
+ * @param url - URL CSV файла
+ * @param options - Опции для csvToJson
+ * @returns Promise с распарсенными данными
+ */
+async function loadCsvFromUrl(url, options = {}) {
+    if (typeof window === 'undefined') {
+        throw new ValidationError('loadCsvFromUrl() работает только в браузере');
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new ValidationError(`Failed to load CSV from URL: ${response.status} ${response.statusText}`);
+    }
+    const text = await response.text();
+    return csvToJson$1(text, options);
+}
+/**
+ * Асинхронная версия loadCsvFromUrl
+ */
+async function loadCsvFromUrlAsync(url, options = {}) {
+    return loadCsvFromUrl(url, options);
+}
+/**
+ * Экспортирует данные в CSV и открывает в новой вкладке
+ *
+ * @param data - Данные для экспорта
+ * @param options - Опции для jsonToCsv
+ */
+function openCsvInNewTab(data, options = {}) {
+    if (typeof window === 'undefined') {
+        throw new ValidationError('openCsvInNewTab() работает только в браузере');
+    }
+    const csv = jsonToCsv$1(data, options);
+    const blob = new Blob([csv], { type: 'text/csv;charset=utf-8' });
+    const url = URL.createObjectURL(blob);
+    window.open(url, '_blank');
+    // Освобождение URL через некоторое время
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+}
+/**
+ * Асинхронная версия openCsvInNewTab
+ */
+async function openCsvInNewTabAsync(data, options = {}) {
+    return openCsvInNewTab(data, options);
+}
+/**
+ * Копирует CSV в буфер обмена
+ *
+ * @param data - Данные для копирования
+ * @param options - Опции для jsonToCsv
+ * @returns Promise с результатом копирования
+ */
+async function copyCsvToClipboard(data, options = {}) {
+    if (typeof window === 'undefined' || !navigator.clipboard) {
+        throw new ValidationError('copyCsvToClipboard() требует поддержки Clipboard API');
+    }
+    const csv = jsonToCsv$1(data, options);
+    try {
+        await navigator.clipboard.writeText(csv);
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to copy to clipboard:', error);
+        return false;
+    }
+}
+/**
+ * Сохраняет CSV в localStorage
+ *
+ * @param key - Ключ для сохранения
+ * @param data - Данные для сохранения
+ * @param options - Опции для jsonToCsv
+ */
+function saveCsvToLocalStorage(key, data, options = {}) {
+    if (typeof window === 'undefined' || !localStorage) {
+        throw new ValidationError('saveCsvToLocalStorage() требует localStorage');
+    }
+    const csv = jsonToCsv$1(data, options);
+    localStorage.setItem(key, csv);
+}
+/**
+ * Загружает CSV из localStorage
+ *
+ * @param key - Ключ для загрузки
+ * @param options - Опции для csvToJson
+ * @returns Распарсенные данные или null
+ */
+function loadCsvFromLocalStorage(key, options = {}) {
+    if (typeof window === 'undefined' || !localStorage) {
+        throw new ValidationError('loadCsvFromLocalStorage() требует localStorage');
+    }
+    const csv = localStorage.getItem(key);
+    if (!csv) {
+        return null;
+    }
+    return csvToJson$1(csv, options);
+}
+/**
+ * Асинхронная версия loadCsvFromLocalStorage
+ */
+async function loadCsvFromLocalStorageAsync(key, options = {}) {
+    return loadCsvFromLocalStorage(key, options);
+}
+/**
+ * Создает CSV файл из JSON данных (альтернатива downloadAsCsv)
+ * Возвращает Blob вместо автоматического скачивания
+ *
+ * @param data - Массив объектов
+ * @param options - Опции для jsonToCsv
+ * @returns CSV Blob
+ */
+function createCsvBlob(data, options = {}) {
+    const csv = jsonToCsv$1(data, options);
+    return new Blob([csv], {
+        type: 'text/csv;charset=utf-8;'
+    });
+}
+/**
+ * Асинхронная версия createCsvBlob
+ */
+async function createCsvBlobAsync(data, options = {}) {
+    return createCsvBlob(data, options);
+}
+/**
+ * Парсит CSV строку из Blob
+ *
+ * @param blob - CSV Blob
+ * @param options - Опции для csvToJson
+ * @returns Promise с JSON данными
+ */
+async function parseCsvBlob(blob, options = {}) {
+    if (!(blob instanceof Blob)) {
+        throw new ValidationError('Input must be a Blob object');
+    }
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = function (event) {
+            try {
+                const csvText = event.target?.result;
+                const json = csvToJson$1(csvText, options);
+                resolve(json);
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        reader.onerror = function () {
+            reject(new ValidationError('Ошибка чтения Blob'));
+        };
+        reader.readAsText(blob, 'UTF-8');
+    });
+}
+/**
+ * Асинхронная версия parseCsvBlob
+ */
+async function parseCsvBlobAsync(blob, options = {}) {
+    return parseCsvBlob(blob, options);
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        downloadAsCsv,
+        downloadAsCsvAsync: downloadAsCsvAsync$1,
+        parseCsvFile,
+        parseCsvFileStream,
+        createCsvBlob,
+        createCsvBlobAsync,
+        parseCsvBlob,
+        parseCsvBlobAsync,
+        jsonToCsvStream,
+        jsonToNdjsonStream,
+        csvToJsonStream,
+        loadCsvFromUrl,
+        loadCsvFromUrlAsync,
+        openCsvInNewTab,
+        openCsvInNewTabAsync,
+        copyCsvToClipboard,
+        saveCsvToLocalStorage,
+        loadCsvFromLocalStorage,
+        loadCsvFromLocalStorageAsync
+    };
+}
+
+// Worker Pool для параллельной обработки CSV
+// Использует Comlink для простой коммуникации с Web Workers
+// Проверка поддержки Web Workers
+const WORKERS_SUPPORTED = typeof Worker !== 'undefined';
+function isTransferableBuffer(value) {
+    if (!(value instanceof ArrayBuffer)) {
+        return false;
+    }
+    if (typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer) {
+        return false;
+    }
+    return true;
+}
+function collectTransferables(args) {
+    const transferables = [];
+    const collectFromValue = (value) => {
+        if (!value) {
+            return;
+        }
+        if (isTransferableBuffer(value)) {
+            transferables.push(value);
+            return;
+        }
+        if (ArrayBuffer.isView(value) && isTransferableBuffer(value.buffer)) {
+            transferables.push(value.buffer);
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach(collectFromValue);
+        }
+    };
+    args.forEach(collectFromValue);
+    return transferables.length ? transferables : null;
+}
+/**
+ * Опции для Worker Pool
+ * @typedef {Object} WorkerPoolOptions
+ * @property {number} [workerCount=4] - Количество workers в pool
+ * @property {number} [maxQueueSize=100] - Максимальный размер очереди задач
+ * @property {boolean} [autoScale=true] - Автоматическое масштабирование pool
+ * @property {number} [idleTimeout=60000] - Таймаут простоя worker (мс)
+ */
+/**
+ * Статистика Worker Pool
+ * @typedef {Object} WorkerPoolStats
+ * @property {number} totalWorkers - Всего workers
+ * @property {number} activeWorkers - Активные workers
+ * @property {number} idleWorkers - Простаивающие workers
+ * @property {number} queueSize - Размер очереди
+ * @property {number} tasksCompleted - Завершенные задачи
+ * @property {number} tasksFailed - Неудачные задачи
+ */
+/**
+ * Прогресс обработки задачи
+ * @typedef {Object} TaskProgress
+ * @property {number} processed - Обработано элементов
+ * @property {number} total - Всего элементов
+ * @property {number} percentage - Процент выполнения
+ * @property {number} speed - Скорость обработки (элементов/сек)
+ */
+/**
+ * Worker Pool для параллельной обработки CSV
+ */
+class WorkerPool {
+    /**
+     * Создает новый Worker Pool
+     * @param {string} workerScript - URL скрипта worker
+     * @param {WorkerPoolOptions} [options] - Опции pool
+     */
+    constructor(workerScript, options = {}) {
+        if (!WORKERS_SUPPORTED) {
+            throw new ValidationError('Web Workers не поддерживаются в этом браузере');
+        }
+        this.workerScript = workerScript;
+        this.options = {
+            workerCount: 4,
+            maxQueueSize: 100,
+            autoScale: true,
+            idleTimeout: 60000,
+            ...options
+        };
+        this.workers = [];
+        this.taskQueue = [];
+        this.activeTasks = new Map();
+        this.stats = {
+            totalWorkers: 0,
+            activeWorkers: 0,
+            idleWorkers: 0,
+            queueSize: 0,
+            tasksCompleted: 0,
+            tasksFailed: 0
+        };
+        this.initializeWorkers();
+    }
+    /**
+     * Инициализация workers
+     * @private
+     */
+    initializeWorkers() {
+        const { workerCount } = this.options;
+        for (let i = 0; i < workerCount; i++) {
+            this.createWorker();
+        }
+        this.updateStats();
+    }
+    /**
+     * Создает нового worker
+     * @private
+     */
+    createWorker() {
+        try {
+            const worker = new Worker(this.workerScript, { type: 'module' });
+            worker.id = `worker-${this.workers.length}`;
+            worker.status = 'idle';
+            worker.lastUsed = Date.now();
+            worker.taskId = null;
+            // Обработчики событий
+            worker.onmessage = (event) => this.handleWorkerMessage(worker, event);
+            worker.onerror = (error) => this.handleWorkerError(worker, error);
+            worker.onmessageerror = (error) => this.handleWorkerMessageError(worker, error);
+            this.workers.push(worker);
+            this.stats.totalWorkers++;
+            this.stats.idleWorkers++;
+            return worker;
+        }
+        catch (error) {
+            throw new ConfigurationError(`Не удалось создать worker: ${error.message}`);
+        }
+    }
+    /**
+     * Обработка сообщений от worker
+     * @private
+     */
+    handleWorkerMessage(worker, event) {
+        const { data } = event;
+        if (data.type === 'PROGRESS') {
+            this.handleProgress(worker, data);
+        }
+        else if (data.type === 'RESULT') {
+            this.handleResult(worker, data);
+        }
+        else if (data.type === 'ERROR') {
+            this.handleWorkerTaskError(worker, data);
+        }
+    }
+    /**
+     * Обработка прогресса задачи
+     * @private
+     */
+    handleProgress(worker, progressData) {
+        const taskId = worker.taskId;
+        if (taskId && this.activeTasks.has(taskId)) {
+            const task = this.activeTasks.get(taskId);
+            if (task.onProgress) {
+                task.onProgress({
+                    processed: progressData.processed,
+                    total: progressData.total,
+                    percentage: (progressData.processed / progressData.total) * 100,
+                    speed: progressData.speed || 0
+                });
+            }
+        }
+    }
+    /**
+     * Обработка результата задачи
+     * @private
+     */
+    handleResult(worker, resultData) {
+        const taskId = worker.taskId;
+        if (taskId && this.activeTasks.has(taskId)) {
+            const task = this.activeTasks.get(taskId);
+            // Освобождение worker
+            worker.status = 'idle';
+            worker.lastUsed = Date.now();
+            worker.taskId = null;
+            this.stats.activeWorkers--;
+            this.stats.idleWorkers++;
+            // Завершение задачи
+            task.resolve(resultData.data);
+            this.activeTasks.delete(taskId);
+            this.stats.tasksCompleted++;
+            // Обработка следующей задачи в очереди
+            this.processQueue();
+            this.updateStats();
+        }
+    }
+    /**
+     * Обработка ошибки задачи
+     * @private
+     */
+    handleWorkerTaskError(worker, errorData) {
+        const taskId = worker.taskId;
+        if (taskId && this.activeTasks.has(taskId)) {
+            const task = this.activeTasks.get(taskId);
+            // Освобождение worker
+            worker.status = 'idle';
+            worker.lastUsed = Date.now();
+            worker.taskId = null;
+            this.stats.activeWorkers--;
+            this.stats.idleWorkers++;
+            // Завершение с ошибкой
+            const workerError = new Error(errorData.message || 'Ошибка в worker');
+            if (errorData.code) {
+                workerError.code = errorData.code;
+            }
+            if (errorData.details) {
+                workerError.details = errorData.details;
+            }
+            task.reject(workerError);
+            this.activeTasks.delete(taskId);
+            this.stats.tasksFailed++;
+            // Обработка следующей задачи
+            this.processQueue();
+            this.updateStats();
+        }
+    }
+    /**
+     * Обработка ошибок worker
+     * @private
+     */
+    handleWorkerError(worker, error) {
+        console.error(`Worker ${worker.id} error:`, error);
+        // Перезапуск worker
+        this.restartWorker(worker);
+    }
+    /**
+     * Обработка ошибок сообщений
+     * @private
+     */
+    handleWorkerMessageError(worker, error) {
+        console.error(`Worker ${worker.id} message error:`, error);
+    }
+    /**
+     * Перезапуск worker
+     * @private
+     */
+    restartWorker(worker) {
+        const index = this.workers.indexOf(worker);
+        if (index !== -1) {
+            // Завершение старого worker
+            worker.terminate();
+            // Удаление из статистики
+            if (worker.status === 'active') {
+                this.stats.activeWorkers--;
+            }
+            else {
+                this.stats.idleWorkers--;
+            }
+            this.stats.totalWorkers--;
+            // Создание нового worker
+            const newWorker = this.createWorker();
+            this.workers[index] = newWorker;
+            // Перезапуск задачи если была активна
+            if (worker.taskId && this.activeTasks.has(worker.taskId)) {
+                const task = this.activeTasks.get(worker.taskId);
+                this.executeTask(newWorker, task);
+            }
+        }
+    }
+    /**
+     * Выполнение задачи на worker
+     * @private
+     */
+    executeTask(worker, task) {
+        worker.status = 'active';
+        worker.lastUsed = Date.now();
+        worker.taskId = task.id;
+        this.stats.idleWorkers--;
+        this.stats.activeWorkers++;
+        // Отправка задачи в worker
+        const payload = {
+            type: 'EXECUTE',
+            taskId: task.id,
+            method: task.method,
+            args: task.args,
+            options: task.options
+        };
+        if (task.transferList && task.transferList.length) {
+            worker.postMessage(payload, task.transferList);
+        }
+        else {
+            worker.postMessage(payload);
+        }
+    }
+    /**
+     * Обработка очереди задач
+     * @private
+     */
+    processQueue() {
+        if (this.taskQueue.length === 0) {
+            return;
+        }
+        while (this.taskQueue.length > 0) {
+            const idleWorker = this.workers.find(w => w.status === 'idle');
+            if (!idleWorker) {
+                if (this.options.autoScale && this.workers.length < this.options.maxQueueSize) {
+                    this.createWorker();
+                    continue;
+                }
+                break;
+            }
+            const task = this.taskQueue.shift();
+            this.stats.queueSize--;
+            this.executeTask(idleWorker, task);
+        }
+        this.updateStats();
+    }
+    /**
+     * Обновление статистики
+     * @private
+     */
+    updateStats() {
+        this.stats.queueSize = this.taskQueue.length;
+    }
+    /**
+     * Выполнение задачи через pool
+     * @param {string} method - Метод для вызова в worker
+     * @param {Array} args - Аргументы метода
+     * @param {Object} [options] - Опции задачи
+     * @param {Function} [onProgress] - Callback прогресса
+     * @returns {Promise<unknown>} Результат выполнения
+     */
+    async exec(method, args = [], options = {}, onProgress = null) {
+        return new Promise((resolve, reject) => {
+            // Проверка размера очереди
+            if (this.taskQueue.length >= this.options.maxQueueSize) {
+                reject(new Error('Очередь задач переполнена'));
+                return;
+            }
+            // Создание задачи
+            const taskId = `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            const { transfer, ...taskOptions } = options || {};
+            const transferList = transfer || collectTransferables(args);
+            const task = {
+                id: taskId,
+                method,
+                args,
+                options: taskOptions,
+                transferList,
+                onProgress,
+                resolve,
+                reject,
+                createdAt: Date.now()
+            };
+            // Добавление в очередь
+            this.taskQueue.push(task);
+            this.stats.queueSize++;
+            // Запуск обработки очереди
+            this.processQueue();
+            this.updateStats();
+        });
+    }
+    /**
+     * Получение статистики pool
+     * @returns {WorkerPoolStats} Статистика
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Очистка простаивающих workers
+     */
+    cleanupIdleWorkers() {
+        const now = Date.now();
+        const { idleTimeout } = this.options;
+        for (let i = this.workers.length - 1; i >= 0; i--) {
+            const worker = this.workers[i];
+            if (worker.status === 'idle' && (now - worker.lastUsed) > idleTimeout) {
+                // Сохранение минимального количества workers
+                if (this.workers.length > 1) {
+                    worker.terminate();
+                    this.workers.splice(i, 1);
+                    this.stats.totalWorkers--;
+                    this.stats.idleWorkers--;
+                }
+            }
+        }
+    }
+    /**
+     * Завершение всех workers
+     */
+    terminate() {
+        this.workers.forEach(worker => {
+            worker.terminate();
+        });
+        this.workers = [];
+        this.taskQueue = [];
+        this.activeTasks.clear();
+        // Сброс статистики
+        this.stats = {
+            totalWorkers: 0,
+            activeWorkers: 0,
+            idleWorkers: 0,
+            queueSize: 0,
+            tasksCompleted: 0,
+            tasksFailed: 0
+        };
+    }
+}
+/**
+ * Создает Worker Pool для обработки CSV
+ * @param {WorkerPoolOptions} [options] - Опции pool
+ * @returns {WorkerPool} Worker Pool
+ */
+function createWorkerPool(options = {}) {
+    // Используем встроенный worker скрипт
+    const baseUrl = typeof document !== 'undefined'
+        ? document.baseURI
+        : (typeof self !== 'undefined' && self.location
+            ? self.location.href
+            : '');
+    const workerScript = new URL('./csv-parser.worker.js', baseUrl).href;
+    return new WorkerPool(workerScript, options);
+}
+/**
+ * Парсит CSV с использованием Web Workers
+ * @param {string|File} csvInput - CSV строка или File объект
+ * @param {Object} [options] - Опции парсинга
+ * @param {Function} [onProgress] - Callback прогресса
+ * @returns {Promise<Array<Object>>} JSON данные
+ */
+async function parseCSVWithWorker(csvInput, options = {}, onProgress = null) {
+    // Создание pool если нужно
+    const poolHolder = parseCSVWithWorker;
+    if (!poolHolder.pool) {
+        poolHolder.pool = createWorkerPool();
+    }
+    const pool = poolHolder.pool;
+    // Подготовка CSV строки
+    // ?????????? CSV ??????
+    let csvPayload = csvInput;
+    let transfer = null;
+    if (csvInput instanceof File) {
+        const buffer = await readFileAsArrayBuffer(csvInput);
+        csvPayload = new Uint8Array(buffer);
+        transfer = [buffer];
+    }
+    else if (csvInput instanceof ArrayBuffer) {
+        csvPayload = csvInput;
+        transfer = [csvInput];
+    }
+    else if (ArrayBuffer.isView(csvInput)) {
+        csvPayload = csvInput;
+        if (csvInput.buffer instanceof ArrayBuffer) {
+            transfer = [csvInput.buffer];
+        }
+    }
+    else if (typeof csvInput !== 'string') {
+        throw new ValidationError('Input must be a CSV string, File, or ArrayBuffer');
+    }
+    // ????????? ?????? ????? pool
+    const execOptions = transfer ? { transfer } : {};
+    return pool.exec('parseCSV', [csvPayload, options], execOptions, onProgress);
+}
+/**
+ * Чтение файла как текст
+ * @private
+ */
+async function readFileAsArrayBuffer(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = (event) => resolve(event.target.result);
+        reader.onerror = (error) => reject(error);
+        reader.readAsArrayBuffer(file);
+    });
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        WorkerPool,
+        createWorkerPool,
+        parseCSVWithWorker
+    };
+}
+
+var workerPool = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WorkerPool: WorkerPool,
+    createWorkerPool: createWorkerPool,
+    parseCSVWithWorker: parseCSVWithWorker
+});
+
+// Браузерный entry point для jtcsv
+// Экспортирует все функции с поддержкой браузера
+const { jsonToCsv, preprocessData, deepUnwrap } = jsonToCsvBrowser;
+const { csvToJson, csvToJsonIterator, autoDetectDelimiter } = csvToJsonBrowser;
+/**
+ * Ленивая инициализация Worker Pool
+ */
+async function createWorkerPoolLazy(options = {}) {
+    const mod = await Promise.resolve().then(function () { return workerPool; });
+    return mod.createWorkerPool(options);
+}
+/**
+ * Ленивый парсинг CSV с использованием Worker
+ */
+async function parseCSVWithWorkerLazy(csvInput, options = {}, onProgress) {
+    const mod = await Promise.resolve().then(function () { return workerPool; });
+    return mod.parseCSVWithWorker(csvInput, options, onProgress);
+}
+/**
+ * Асинхронная версия jsonToCsv
+ */
+async function jsonToCsvAsync(data, options = {}) {
+    return jsonToCsv(data, options);
+}
+/**
+ * Асинхронная версия csvToJson
+ */
+async function csvToJsonAsync(csv, options = {}) {
+    return csvToJson(csv, options);
+}
+/**
+ * Асинхронная версия parseCsvFile
+ */
+async function parseCsvFileAsync(file, options = {}) {
+    return parseCsvFile(file, options);
+}
+/**
+ * Асинхронная версия autoDetectDelimiter
+ */
+async function autoDetectDelimiterAsync(csv) {
+    return autoDetectDelimiter(csv);
+}
+/**
+ * Асинхронная версия downloadAsCsv
+ */
+async function downloadAsCsvAsync(data, filename = 'export.csv', options = {}) {
+    return downloadAsCsv(data, filename, options);
+}
+// Основной экспорт
+const jtcsv = {
+    // JSON to CSV функции
+    jsonToCsv,
+    preprocessData,
+    downloadAsCsv,
+    deepUnwrap,
+    // CSV to JSON функции
+    csvToJson,
+    csvToJsonIterator,
+    parseCsvFile,
+    parseCsvFileStream,
+    jsonToCsvStream,
+    jsonToNdjsonStream,
+    csvToJsonStream,
+    autoDetectDelimiter,
+    // Web Workers функции
+    createWorkerPool,
+    parseCSVWithWorker,
+    createWorkerPoolLazy,
+    parseCSVWithWorkerLazy,
+    // Асинхронные функции
+    jsonToCsvAsync,
+    csvToJsonAsync,
+    parseCsvFileAsync,
+    autoDetectDelimiterAsync,
+    downloadAsCsvAsync,
+    // Error classes
+    ValidationError,
+    SecurityError,
+    FileSystemError,
+    ParsingError,
+    LimitError,
+    ConfigurationError,
+    ERROR_CODES,
+    // Удобные алиасы
+    parse: csvToJson,
+    unparse: jsonToCsv,
+    parseAsync: csvToJsonAsync,
+    unparseAsync: jsonToCsvAsync,
+    // Версия
+    version: '2.0.0-browser'
+};
+// Экспорт для разных сред
+if (typeof module !== 'undefined' && module.exports) {
+    // Node.js CommonJS
+    module.exports = jtcsv;
+}
+else if (typeof define === 'function' && define.amd) {
+    // AMD
+    define([], () => jtcsv);
+}
+else if (typeof window !== 'undefined') {
+    // Браузер (глобальная переменная)
+    window.jtcsv = jtcsv;
+}
+
+exports.ConfigurationError = ConfigurationError;
+exports.ERROR_CODES = ERROR_CODES;
+exports.FileSystemError = FileSystemError;
+exports.LimitError = LimitError;
+exports.ParsingError = ParsingError;
+exports.SecurityError = SecurityError;
+exports.ValidationError = ValidationError;
+exports.autoDetectDelimiter = autoDetectDelimiter;
+exports.autoDetectDelimiterAsync = autoDetectDelimiterAsync;
+exports.createWorkerPool = createWorkerPool;
+exports.createWorkerPoolLazy = createWorkerPoolLazy;
+exports.csvToJson = csvToJson;
+exports.csvToJsonAsync = csvToJsonAsync;
+exports.csvToJsonIterator = csvToJsonIterator;
+exports.csvToJsonStream = csvToJsonStream;
+exports.deepUnwrap = deepUnwrap;
+exports.default = jtcsv;
+exports.downloadAsCsv = downloadAsCsv;
+exports.downloadAsCsvAsync = downloadAsCsvAsync;
+exports.jsonToCsv = jsonToCsv;
+exports.jsonToCsvAsync = jsonToCsvAsync;
+exports.jsonToCsvStream = jsonToCsvStream;
+exports.jsonToNdjsonStream = jsonToNdjsonStream;
+exports.parseCSVWithWorker = parseCSVWithWorker;
+exports.parseCSVWithWorkerLazy = parseCSVWithWorkerLazy;
+exports.parseCsvFile = parseCsvFile;
+exports.parseCsvFileAsync = parseCsvFileAsync;
+exports.parseCsvFileStream = parseCsvFileStream;
+exports.preprocessData = preprocessData;
+//# sourceMappingURL=jtcsv-full.cjs.js.map