jtcsv 2.2.8 → 3.1.0

package/dist/jtcsv.cjs.js

@@ -2,1496 +2,1340 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // Система ошибок для браузерной версии 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);
+    constructor(message, code = 'JTCSV_ERROR', details = {}) {
+        super(message);
+        this.name = 'JTCSVError';
+        this.code = code;
+        this.details = details;
+        this.hint = details.hint;
+        this.docs = details.docs;
+        this.context = details.context;
+        // Сохранение stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, JTCSVError);
+        }
     }
-  }
 }
-
 /**
  * Ошибка валидации
  */
 class ValidationError extends JTCSVError {
-  constructor(message, details = {}) {
-    super(message, 'VALIDATION_ERROR', details);
-    this.name = 'ValidationError';
-  }
+    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';
-  }
+    constructor(message, details = {}) {
+        super(message, 'SECURITY_ERROR', details);
+        this.name = 'SecurityError';
+    }
 }
-
 /**
  * Ошибка файловой системы (адаптирована для браузера)
  */
 class FileSystemError extends JTCSVError {
-  constructor(message, originalError = null, details = {}) {
-    super(message, 'FILE_SYSTEM_ERROR', {
-      ...details,
-      originalError
-    });
-    this.name = 'FileSystemError';
-    if (originalError && originalError.code) {
-      this.code = originalError.code;
+    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 = null, details = {}) {
-    super(message, 'PARSING_ERROR', {
-      ...details,
-      lineNumber
-    });
-    this.name = 'ParsingError';
-    this.lineNumber = lineNumber;
-  }
+    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;
-  }
+    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';
-  }
+    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'
+    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 {Function} fn - Функция для выполнения
- * @param {string} errorCode - Код ошибки по умолчанию
- * @param {Object} errorDetails - Детали ошибки
- * @returns {*} Результат выполнения функции
+ *
+ * @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, null, {
-        ...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
-      });
+    try {
+        if (typeof fn === 'function') {
+            return fn();
+        }
+        throw new ValidationError('Function expected');
     }
-
-    // Сохранить оригинальный stack trace если возможно
-    if (error.stack) {
-      enhancedError.stack = error.stack;
+    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;
     }
-    throw enhancedError;
-  }
 }
-
 /**
  * Асинхронная версия safeExecute
  */
 async function safeExecuteAsync(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
-  try {
-    if (typeof fn === 'function') {
-      return await fn();
+    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;
     }
-    throw new ValidationError('Function expected');
-  } catch (error) {
-    // Если ошибка уже является JTCSVError, перебросить её
+}
+/**
+ * Создать сообщение об ошибке
+ */
+function createErrorMessage(error, includeStack = false) {
+    let message = error.message || 'Unknown error';
     if (error instanceof JTCSVError) {
-      throw error;
+        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 (error.hint) {
+            message += `\nHint: ${error.hint}`;
+        }
+        if (error.docs) {
+            message += `\nDocs: ${error.docs}`;
+        }
     }
-
-    // Определить тип ошибки
-    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, null, {
-        ...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;
-  }
+    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
-  };
+    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 !== null && options !== void 0 && options.delimiter && typeof options.delimiter !== 'string') {
-    throw new ConfigurationError('Delimiter must be a string');
-  }
-  if (options !== null && options !== void 0 && options.delimiter && options.delimiter.length !== 1) {
-    throw new ConfigurationError('Delimiter must be a single character');
-  }
-
-  // Validate renameMap
-  if (options !== null && options !== void 0 && 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 data
+    if (!Array.isArray(data)) {
+        throw new ValidationError('Input data must be an array');
     }
-  }
-
-  // Validate preventCsvInjection
-  if ((options === null || options === void 0 ? void 0 : options.preventCsvInjection) !== undefined && typeof options.preventCsvInjection !== 'boolean') {
-    throw new ConfigurationError('preventCsvInjection must be a boolean');
-  }
-
-  // Validate rfc4180Compliant
-  if ((options === null || options === void 0 ? void 0 : options.rfc4180Compliant) !== undefined && typeof options.rfc4180Compliant !== 'boolean') {
-    throw new ConfigurationError('rfc4180Compliant must be a boolean');
-  }
-  return true;
-}
-
-/**
- * Конвертирует JSON данные в CSV формат
- * 
- * @param {Array<Object>} data - Массив объектов для конвертации в CSV
- * @param {Object} [options] - Опции конфигурации
- * @param {string} [options.delimiter=';'] - CSV разделитель
- * @param {boolean} [options.includeHeaders=true] - Включать ли заголовки
- * @param {Object} [options.renameMap={}] - Маппинг переименования заголовков
- * @param {Object} [options.template={}] - Шаблон для порядка колонок
- * @param {number} [options.maxRecords] - Максимальное количество записей
- * @param {boolean} [options.preventCsvInjection=true] - Защита от CSV инъекций
- * @param {boolean} [options.rfc4180Compliant=true] - Соответствие RFC 4180
- * @returns {string} CSV строка
- */
-function jsonToCsv(data, options = {}) {
-  return safeExecute(() => {
-    // Валидация входных данных
-    validateInput(data, options);
-    const opts = options && typeof options === 'object' ? options : {};
-    const {
-      delimiter = ';',
-      includeHeaders = true,
-      renameMap = {},
-      template = {},
-      maxRecords,
-      preventCsvInjection = true,
-      rfc4180Compliant = true
-    } = opts;
-
-    // Обработка пустых данных
-    if (data.length === 0) {
-      return '';
+    // Validate options
+    if (options && typeof options !== 'object') {
+        throw new ConfigurationError('Options must be an object');
     }
-
-    // Предупреждение для больших наборов данных
-    if (data.length > 1000000 && !maxRecords && process.env.NODE_ENV !== 'production') {
-      console.warn('⚠️ Warning: Processing >1M records in memory may be slow.\n' + '💡 Consider processing data in batches or using Web Workers for large files.\n' + '📊 Current size: ' + data.length.toLocaleString() + ' records');
+    // Validate delimiter
+    if (options?.delimiter && typeof options.delimiter !== 'string') {
+        throw new ConfigurationError('Delimiter must be a string');
     }
-
-    // Применение ограничения по количеству записей
-    if (maxRecords && data.length > maxRecords) {
-      throw new LimitError(`Data size exceeds maximum limit of ${maxRecords} records`, maxRecords, data.length);
+    if (options?.delimiter && options.delimiter.length !== 1) {
+        throw new ConfigurationError('Delimiter must be a single character');
     }
-
-    // Получение всех уникальных ключей
-    const allKeys = new Set();
-    data.forEach(item => {
-      if (!item || typeof item !== 'object') {
-        return;
-      }
-      Object.keys(item).forEach(key => allKeys.add(key));
-    });
-    const originalKeys = Array.from(allKeys);
-
-    // Применение rename map для создания заголовков
-    const headers = originalKeys.map(key => renameMap[key] || key);
-
-    // Создание обратного маппинга
-    const reverseRenameMap = {};
-    originalKeys.forEach((key, index) => {
-      reverseRenameMap[headers[index]] = key;
-    });
-
-    // Применение порядка из шаблона
-    let finalHeaders = headers;
-    if (Object.keys(template).length > 0) {
-      const templateHeaders = Object.keys(template).map(key => renameMap[key] || key);
-      const extraHeaders = headers.filter(h => !templateHeaders.includes(h));
-      finalHeaders = [...templateHeaders, ...extraHeaders];
+    // Validate renameMap
+    if (options?.renameMap && typeof options.renameMap !== 'object') {
+        throw new ConfigurationError('renameMap must be an object');
     }
-
-    /**
-     * Экранирование значения для CSV с защитой от инъекций
-     * @private
-     */
-    const escapeValue = value => {
-      if (value === null || value === undefined || value === '') {
-        return '';
-      }
-      const stringValue = String(value);
-
-      // Защита от CSV инъекций
-      let escapedValue = stringValue;
-      if (preventCsvInjection && /^[=+\-@]/.test(stringValue)) {
-        escapedValue = "'" + stringValue;
-      }
-
-      // Соответствие RFC 4180
-      const needsQuoting = rfc4180Compliant ? escapedValue.includes(delimiter) || escapedValue.includes('"') || escapedValue.includes('\n') || escapedValue.includes('\r') : escapedValue.includes(delimiter) || escapedValue.includes('"') || escapedValue.includes('\n') || escapedValue.includes('\r');
-      if (needsQuoting) {
-        return `"${escapedValue.replace(/"/g, '""')}"`;
-      }
-      return escapedValue;
-    };
-
-    // Построение CSV строк
-    const rows = [];
-
-    // Добавление заголовков
-    if (includeHeaders && finalHeaders.length > 0) {
-      rows.push(finalHeaders.join(delimiter));
+    // Validate maxRecords
+    if (options && options.maxRecords !== undefined) {
+        if (typeof options.maxRecords !== 'number' || options.maxRecords <= 0) {
+            throw new ConfigurationError('maxRecords must be a positive number');
+        }
     }
-
-    // Добавление данных
-    for (const item of data) {
-      if (!item || typeof item !== 'object') {
-        continue;
-      }
-      const row = finalHeaders.map(header => {
-        const originalKey = reverseRenameMap[header] || header;
-        const value = item[originalKey];
-        return escapeValue(value);
-      }).join(delimiter);
-      rows.push(row);
+    // Validate preventCsvInjection
+    if (options?.preventCsvInjection !== undefined && typeof options.preventCsvInjection !== 'boolean') {
+        throw new ConfigurationError('preventCsvInjection must be a boolean');
     }
-
-    // Разделители строк согласно RFC 4180
-    const lineEnding = rfc4180Compliant ? '\r\n' : '\n';
-    return rows.join(lineEnding);
-  }, 'PARSE_FAILED', {
-    function: 'jsonToCsv'
-  });
+    // Validate rfc4180Compliant
+    if (options?.rfc4180Compliant !== undefined && typeof options.rfc4180Compliant !== 'boolean') {
+        throw new ConfigurationError('rfc4180Compliant must be a boolean');
+    }
+    if (options?.normalizeQuotes !== undefined && typeof options.normalizeQuotes !== 'boolean') {
+        throw new ConfigurationError('normalizeQuotes must be a boolean');
+    }
+    return true;
 }
-
 /**
- * Глубокое разворачивание вложенных объектов и массивов
- * 
- * @param {*} value - Значение для разворачивания
- * @param {number} [depth=0] - Текущая глубина рекурсии
- * @param {number} [maxDepth=5] - Максимальная глубина рекурсии
- * @param {Set} [visited=new Set()] - Посещенные объекты для обнаружения циклических ссылок
- * @returns {string} Развернутое строковое значение
- */
-function deepUnwrap(value, depth = 0, maxDepth = 5, visited = new Set()) {
-  // Проверка глубины
-  if (depth >= maxDepth) {
-    return '[Too Deep]';
-  }
-  if (value === null || value === undefined) {
-    return '';
-  }
-
-  // Обработка циклических ссылок
-  if (typeof value === 'object') {
-    if (visited.has(value)) {
-      return '[Circular Reference]';
+ * Экранирование CSV значений для предотвращения инъекций
+ * @private
+ */
+function escapeCsvValue(value, preventInjection = true) {
+    if (value === null || value === undefined) {
+        return '';
     }
-    visited.add(value);
-  }
-
-  // Обработка массивов
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return '';
-    }
-    const unwrappedItems = value.map(item => deepUnwrap(item, depth + 1, maxDepth, visited)).filter(item => item !== '');
-    return unwrappedItems.join(', ');
-  }
-
-  // Обработка объектов
-  if (typeof value === 'object') {
-    const keys = Object.keys(value);
-    if (keys.length === 0) {
-      return '';
+    const str = String(value);
+    const isPotentialFormula = (input) => {
+        let idx = 0;
+        while (idx < input.length) {
+            const code = input.charCodeAt(idx);
+            if (code === 32 || code === 9 || code === 10 || code === 13 || code === 0xfeff) {
+                idx++;
+                continue;
+            }
+            break;
+        }
+        if (idx < input.length && (input[idx] === '"' || input[idx] === "'")) {
+            idx++;
+            while (idx < input.length) {
+                const code = input.charCodeAt(idx);
+                if (code === 32 || code === 9) {
+                    idx++;
+                    continue;
+                }
+                break;
+            }
+        }
+        if (idx >= input.length) {
+            return false;
+        }
+        const char = input[idx];
+        return char === '=' || char === '+' || char === '-' || char === '@';
+    };
+    // Экранирование формул для предотвращения CSV инъекций
+    if (preventInjection && isPotentialFormula(str)) {
+        return "'" + str;
     }
-    if (depth + 1 >= maxDepth) {
-      return '[Too Deep]';
+    // Экранирование кавычек и переносов строк
+    if (str.includes('"') || str.includes('\n') || str.includes('\r') || str.includes(',')) {
+        return '"' + str.replace(/"/g, '""') + '"';
     }
-
-    // Сериализация сложных объектов
-    try {
-      return JSON.stringify(value);
-    } catch (error) {
-      if (error.message.includes('circular') || error.message.includes('Converting circular')) {
-        return '[Circular Reference]';
-      }
-      return '[Unstringifiable Object]';
-    }
-  }
-
-  // Примитивные значения
-  return String(value);
+    return str;
 }
-
-/**
- * Предобработка JSON данных путем глубокого разворачивания вложенных структур
- * 
- * @param {Array<Object>} data - Массив объектов для предобработки
- * @returns {Array<Object>} Предобработанные данные с развернутыми значениями
- */
-function preprocessData(data) {
-  if (!Array.isArray(data)) {
-    return [];
-  }
-  return data.map(item => {
-    if (!item || typeof item !== 'object') {
-      return {};
-    }
-    const processed = {};
-    for (const key in item) {
-      if (Object.prototype.hasOwnProperty.call(item, key)) {
-        const value = item[key];
-        if (value && typeof value === 'object') {
-          processed[key] = deepUnwrap(value);
-        } else {
-          processed[key] = value;
-        }
-      }
-    }
-    return processed;
-  });
+function normalizeQuotesInField$2(value) {
+    // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+    // Проверяем, выглядит ли значение как JSON (объект или массив)
+    if ((value.startsWith('{') && value.endsWith('}')) ||
+        (value.startsWith('[') && value.endsWith(']'))) {
+        return value; // Возвращаем как есть для JSON
+    }
+    let normalized = value.replace(/"{2,}/g, '"');
+    // Убираем правило, которое ломает JSON: не заменяем "," на ","
+    // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+    normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+    if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+        normalized = normalized.slice(1, -1);
+    }
+    return normalized;
 }
-
-// Экспорт для Node.js совместимости
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = {
-    jsonToCsv,
-    preprocessData,
-    deepUnwrap
-  };
+function normalizePhoneValue$2(value) {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return trimmed;
+    }
+    return trimmed.replace(/["'\\]/g, '');
+}
+function normalizeValueForCsv$1(value, key, normalizeQuotes) {
+    if (!normalizeQuotes || typeof value !== 'string') {
+        return value;
+    }
+    const base = normalizeQuotesInField$2(value);
+    if (!key) {
+        return base;
+    }
+    const phoneKeys = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+    if (phoneKeys.has(String(key).toLowerCase())) {
+        return normalizePhoneValue$2(base);
+    }
+    return base;
 }
-
-// Браузерная версия 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 !== null && options !== void 0 && options.delimiter && typeof options.delimiter !== 'string') {
-    throw new ConfigurationError('Delimiter must be a string');
-  }
-  if (options !== null && options !== void 0 && options.delimiter && options.delimiter.length !== 1) {
-    throw new ConfigurationError('Delimiter must be a single character');
-  }
-
-  // Validate autoDetect
-  if ((options === null || options === void 0 ? void 0 : options.autoDetect) !== undefined && typeof options.autoDetect !== 'boolean') {
-    throw new ConfigurationError('autoDetect must be a boolean');
-  }
-
-  // Validate candidates
-  if (options !== null && options !== void 0 && options.candidates && !Array.isArray(options.candidates)) {
-    throw new ConfigurationError('candidates must be an array');
-  }
-
-  // Validate maxRows
-  if ((options === null || options === void 0 ? void 0 : options.maxRows) !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
-    throw new ConfigurationError('maxRows must be a positive number');
-  }
-  if ((options === null || options === void 0 ? void 0 : options.warnExtraFields) !== undefined && typeof options.warnExtraFields !== 'boolean') {
-    throw new ConfigurationError('warnExtraFields must be a boolean');
-  }
-  return true;
+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 ввода и опций
- * @private
+ * Конвертация массива объектов в CSV строку
+ *
+ * @param data - Массив объектов для конвертации
+ * @param options - Опции конвертации
+ * @returns CSV строка
  */
-function validateCsvInput(csv, options) {
-  // Validate CSV input
-  if (typeof csv !== 'string') {
-    throw new ValidationError('Input must be a CSV string');
-  }
-  return validateCsvOptions(options);
+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 normalizeQuotes = options.normalizeQuotes !== 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];
+                const normalized = normalizeValueForCsv$1(value, key, normalizeQuotes);
+                return escapeCsvValue(normalized, preventInjection);
+            });
+            lines.push(rowValues.join(delimiter));
+        }
+        // RFC 4180 compliance: CRLF line endings
+        if (rfc4180Compliant) {
+            return lines.join('\r\n');
+        }
+        return lines.join('\n');
+    });
 }
-
 /**
- * Парсинг одной строки CSV с правильным экранированием
- * @private
+ * Асинхронная версия jsonToCsv
  */
-function parseCsvLine(line, lineNumber, delimiter) {
-  const fields = [];
-  let currentField = '';
-  let insideQuotes = false;
-  let escapeNext = false;
-  for (let i = 0; i < line.length; i++) {
-    const char = line[i];
-    if (escapeNext) {
-      currentField += char;
-      escapeNext = false;
-      continue;
-    }
-    if (char === '\\') {
-      if (i + 1 === line.length) {
-        // Обратный слеш в конце строки
-        currentField += char;
-      } else if (line[i + 1] === '\\') {
-        // Двойной обратный слеш
-        currentField += char;
-        i++; // Пропустить следующий слеш
-      } else {
-        // Экранирование следующего символа
-        escapeNext = true;
-      }
-      continue;
-    }
-    if (char === '"') {
-      if (insideQuotes) {
-        if (i + 1 < line.length && line[i + 1] === '"') {
-          // Экранированная кавычка внутри кавычек
-          currentField += '"';
-          i++; // Пропустить следующую кавычку
-
-          // Проверка конца поля
-          let isEndOfField = false;
-          let j = i + 1;
-          while (j < line.length && (line[j] === ' ' || line[j] === '\t')) {
-            j++;
-          }
-          if (j === line.length || line[j] === delimiter) {
-            isEndOfField = true;
-          }
-          if (isEndOfField) {
-            insideQuotes = false;
-          }
-        } else {
-          // Проверка конца поля
-          let isEndOfField = false;
-          let j = i + 1;
-          while (j < line.length && (line[j] === ' ' || line[j] === '\t')) {
-            j++;
-          }
-          if (j === line.length || line[j] === delimiter) {
-            isEndOfField = true;
-          }
-          if (isEndOfField) {
-            insideQuotes = false;
-          } else {
-            currentField += '"';
-          }
-        }
-      } else {
-        // Начало поля в кавычках
-        insideQuotes = true;
-      }
-      continue;
-    }
-    if (!insideQuotes && char === delimiter) {
-      // Конец поля
-      fields.push(currentField);
-      currentField = '';
-      continue;
-    }
-    currentField += char;
-  }
-
-  // Обработка незавершенного экранирования
-  if (escapeNext) {
-    currentField += '\\';
-  }
-
-  // Добавление последнего поля
-  fields.push(currentField);
-
-  // Проверка незакрытых кавычек
-  if (insideQuotes) {
-    throw new ParsingError('Unclosed quotes in CSV', lineNumber);
-  }
-
-  // Валидация количества полей
-  if (fields.length === 0) {
-    throw new ParsingError('No fields found', lineNumber);
-  }
-  return fields;
+async function jsonToCsvAsync$1(data, options = {}) {
+    return jsonToCsv$1(data, options);
 }
-
 /**
- * Парсинг значения на основе опций
- * @private
+ * Создает итератор для потоковой конвертации JSON в CSV
+ *
+ * @param data - Массив объектов или async итератор
+ * @param options - Опции конвертации
+ * @returns AsyncIterator с CSV чанками
  */
-function parseCsvValue(value, options) {
-  const {
-    trim = true,
-    parseNumbers = false,
-    parseBooleans = false
-  } = options;
-  let result = value;
-  if (trim) {
-    result = result.trim();
-  }
-
-  // Удаление защиты формул Excel
-  if (result.startsWith("'")) {
-    result = result.substring(1);
-  }
-
-  // Парсинг чисел
-  if (parseNumbers && /^-?\d+(\.\d+)?$/.test(result)) {
-    const num = parseFloat(result);
-    if (!isNaN(num)) {
-      return num;
+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;
+    const normalizeQuotes = options.normalizeQuotes !== 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];
+                const normalized = normalizeValueForCsv$1(value, key, normalizeQuotes);
+                return escapeCsvValue(normalized, preventInjection);
+            });
+            yield rowValues.join(delimiter) + (rfc4180Compliant ? '\r\n' : '\n');
+        }
     }
-  }
-
-  // Парсинг булевых значений
-  if (parseBooleans) {
-    const lowerValue = result.toLowerCase();
-    if (lowerValue === 'true') {
-      return true;
+    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);
     }
-    if (lowerValue === 'false') {
-      return false;
+    catch (error) {
+        console.error('JSON to CSV conversion error:', error);
+        return null;
     }
-  }
-
-  // Пустые строки как null
-  if (result === '') {
-    return null;
-  }
-  return result;
-}
-function isSimpleCsv(csv) {
-  return csv.indexOf('"') === -1 && csv.indexOf('\\') === -1;
-}
-function parseSimpleCsv(csv, delimiter, options) {
-  const {
-    hasHeaders = true,
-    renameMap = {},
-    trim = true,
-    parseNumbers = false,
-    parseBooleans = false,
-    maxRows
-  } = options;
-  const result = [];
-  let headers = null;
-  let fieldStart = 0;
-  let currentRow = [];
-  let rowHasData = false;
-  let rowCount = 0;
-  const finalizeRow = fields => {
-    if (fields.length === 1 && fields[0].trim() === '') {
-      return;
-    }
-    if (!headers) {
-      if (hasHeaders) {
-        headers = fields.map(header => {
-          const trimmed = trim ? header.trim() : header;
-          return renameMap[trimmed] || trimmed;
-        });
-        return;
-      }
-      headers = fields.map((_, index) => `column${index + 1}`);
-    }
-    rowCount++;
-    if (maxRows && rowCount > maxRows) {
-      throw new LimitError(`CSV size exceeds maximum limit of ${maxRows} rows`, maxRows, rowCount);
-    }
-    const row = {};
-    const fieldCount = Math.min(fields.length, headers.length);
-    for (let i = 0; i < fieldCount; i++) {
-      row[headers[i]] = parseCsvValue(fields[i], {
-        trim,
-        parseNumbers,
-        parseBooleans
-      });
-    }
-    result.push(row);
-  };
-  let i = 0;
-  while (i <= csv.length) {
-    const char = i < csv.length ? csv[i] : '\n';
-    if (char !== '\r' && char !== '\n' && char !== ' ' && char !== '\t') {
-      rowHasData = true;
-    }
-    if (char === delimiter || char === '\n' || char === '\r' || i === csv.length) {
-      const field = csv.slice(fieldStart, i);
-      currentRow.push(field);
-      if (char === '\n' || char === '\r' || i === csv.length) {
-        if (rowHasData || currentRow.length > 1) {
-          finalizeRow(currentRow);
-        }
-        currentRow = [];
-        rowHasData = false;
-      }
-      if (char === '\r' && csv[i + 1] === '\n') {
-        i++;
-      }
-      fieldStart = i + 1;
-    }
-    i++;
-  }
-  return result;
 }
-
 /**
- * Автоматическое определение разделителя CSV
- * 
- * @param {string} csv - CSV строка
- * @param {Array} [candidates=[';', ',', '\t', '|']] - Кандидаты на разделитель
- * @returns {string} Определенный разделитель
- */
-function autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|']) {
-  if (!csv || typeof csv !== 'string') {
-    return ';'; // значение по умолчанию
-  }
-  const lines = csv.split('\n').filter(line => line.trim().length > 0);
-  if (lines.length === 0) {
-    return ';'; // значение по умолчанию
-  }
-
-  // Использование первой непустой строки для определения
-  const firstLine = lines[0];
-  const counts = {};
-  candidates.forEach(delim => {
-    const escapedDelim = delim.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const regex = new RegExp(escapedDelim, 'g');
-    const matches = firstLine.match(regex);
-    counts[delim] = matches ? matches.length : 0;
-  });
-
-  // Поиск разделителя с максимальным количеством
-  let maxCount = -1;
-  let detectedDelimiter = ';'; // значение по умолчанию
-
-  for (const [delim, count] of Object.entries(counts)) {
-    if (count > maxCount) {
-      maxCount = count;
-      detectedDelimiter = delim;
+ * Асинхронная версия jsonToCsvSafe
+ */
+async function jsonToCsvSafeAsync(data, options = {}) {
+    try {
+        return await jsonToCsvAsync$1(data, options);
     }
-  }
-
-  // Если разделитель не найден или ничья
-  if (maxCount === 0) {
-    return ';'; // значение по умолчанию
-  }
-  return detectedDelimiter;
+    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
+    };
 }
 
-/**
- * Конвертирует CSV строку в JSON массив
- * 
- * @param {string} csv - CSV строка для конвертации
- * @param {Object} [options] - Опции конфигурации
- * @param {string} [options.delimiter] - CSV разделитель (по умолчанию: автоопределение)
- * @param {boolean} [options.autoDetect=true] - Автоопределение разделителя
- * @param {Array} [options.candidates=[';', ',', '\t', '|']] - Кандидаты для автоопределения
- * @param {boolean} [options.hasHeaders=true] - Есть ли заголовки в CSV
- * @param {Object} [options.renameMap={}] - Маппинг переименования заголовков
- * @param {boolean} [options.trim=true] - Обрезать пробелы
- * @param {boolean} [options.parseNumbers=false] - Парсить числовые значения
- * @param {boolean} [options.parseBooleans=false] - Парсить булевы значения
- * @param {number} [options.maxRows] - Максимальное количество строк
- * @returns {Array<Object>} JSON массив
- */
-function csvToJson(csv, options = {}) {
-  return safeExecute(() => {
-    // Валидация ввода
-    validateCsvInput(csv, options);
-    const opts = options && typeof options === 'object' ? options : {};
-    const {
-      delimiter,
-      autoDetect = true,
-      candidates = [';', ',', '\t', '|'],
-      hasHeaders = true,
-      renameMap = {},
-      trim = true,
-      parseNumbers = false,
-      parseBooleans = false,
-      maxRows,
-      warnExtraFields = true
-    } = opts;
+var jsonToCsvBrowser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    jsonToCsv: jsonToCsv$1,
+    jsonToCsvAsync: jsonToCsvAsync$1,
+    jsonToCsvIterator: jsonToCsvIterator,
+    jsonToCsvIteratorAsync: jsonToCsvIteratorAsync,
+    jsonToCsvSafe: jsonToCsvSafe,
+    jsonToCsvSafeAsync: jsonToCsvSafeAsync
+});
 
-    // Определение разделителя
-    let finalDelimiter = delimiter;
-    if (!finalDelimiter && autoDetect) {
-      finalDelimiter = autoDetectDelimiter(csv, candidates);
+// Браузерная версия 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');
     }
-    finalDelimiter = finalDelimiter || ';'; // fallback
-
-    // Обработка пустого CSV
-    if (csv.trim() === '') {
-      return [];
-    }
-    if (isSimpleCsv(csv)) {
-      return parseSimpleCsv(csv, finalDelimiter, {
-        hasHeaders,
-        renameMap,
-        trim,
-        parseNumbers,
-        parseBooleans,
-        maxRows
-      });
+    // Validate delimiter
+    if (options?.delimiter && typeof options.delimiter !== 'string') {
+        throw new ConfigurationError('Delimiter must be a string');
     }
-
-    // Парсинг CSV с обработкой кавычек и переносов строк
-    const lines = [];
-    let currentLine = '';
-    let insideQuotes = false;
-    for (let i = 0; i < csv.length; i++) {
-      const char = csv[i];
-      if (char === '"') {
-        if (insideQuotes && i + 1 < csv.length && csv[i + 1] === '"') {
-          // Экранированная кавычка внутри кавычек
-          currentLine += '"';
-          i++; // Пропустить следующую кавычку
-        } else {
-          // Переключение режима кавычек
-          insideQuotes = !insideQuotes;
-        }
-        currentLine += char;
-        continue;
-      }
-      if (char === '\n' && !insideQuotes) {
-        // Конец строки (вне кавычек)
-        lines.push(currentLine);
-        currentLine = '';
-        continue;
-      }
-      if (char === '\r') {
-        // Игнорировать carriage return
-        continue;
-      }
-      currentLine += char;
+    if (options?.delimiter && options.delimiter.length !== 1) {
+        throw new ConfigurationError('Delimiter must be a single character');
     }
-
-    // Добавление последней строки
-    if (currentLine !== '' || insideQuotes) {
-      lines.push(currentLine);
+    // Validate autoDetect
+    if (options?.autoDetect !== undefined && typeof options.autoDetect !== 'boolean') {
+        throw new ConfigurationError('autoDetect must be a boolean');
     }
-    if (lines.length === 0) {
-      return [];
+    // Validate candidates
+    if (options?.candidates && !Array.isArray(options.candidates)) {
+        throw new ConfigurationError('candidates must be an array');
     }
-
-    // Предупреждение для больших наборов данных
-    if (lines.length > 1000000 && !maxRows && process.env.NODE_ENV !== 'production') {
-      console.warn('⚠️ Warning: Processing >1M records in memory may be slow.\n' + '💡 Consider using Web Workers for better performance with large files.\n' + '📊 Current size: ' + lines.length.toLocaleString() + ' rows');
+    // Validate maxRows
+    if (options?.maxRows !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
+        throw new ConfigurationError('maxRows must be a positive number');
     }
-
-    // Применение ограничения по строкам
-    if (maxRows && lines.length > maxRows) {
-      throw new LimitError(`CSV size exceeds maximum limit of ${maxRows} rows`, maxRows, lines.length);
+    if (options?.warnExtraFields !== undefined && typeof options.warnExtraFields !== 'boolean') {
+        throw new ConfigurationError('warnExtraFields must be a boolean');
     }
-    let headers = [];
-    let startIndex = 0;
-
-    // Парсинг заголовков если есть
-    if (hasHeaders && lines.length > 0) {
-      try {
-        headers = parseCsvLine(lines[0], 1, finalDelimiter).map(header => {
-          const trimmed = trim ? header.trim() : header;
-          return renameMap[trimmed] || trimmed;
-        });
-        startIndex = 1;
-      } catch (error) {
-        if (error instanceof ParsingError) {
-          throw new ParsingError(`Failed to parse headers: ${error.message}`, 1);
-        }
-        throw error;
-      }
-    } else {
-      // Генерация числовых заголовков из первой строки
-      try {
-        const firstLineFields = parseCsvLine(lines[0], 1, finalDelimiter);
-        headers = firstLineFields.map((_, index) => `column${index + 1}`);
-      } catch (error) {
-        if (error instanceof ParsingError) {
-          throw new ParsingError(`Failed to parse first line: ${error.message}`, 1);
-        }
-        throw error;
-      }
+    if (options?.repairRowShifts !== undefined && typeof options.repairRowShifts !== 'boolean') {
+        throw new ConfigurationError('repairRowShifts must be a boolean');
     }
-
-    // Парсинг строк данных
-    const result = [];
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-
-      // Пропуск пустых строк
-      if (line.trim() === '') {
-        continue;
-      }
-      try {
-        const fields = parseCsvLine(line, i + 1, finalDelimiter);
-
-        // Обработка несоответствия количества полей
-        const row = {};
-        const fieldCount = Math.min(fields.length, headers.length);
-        for (let j = 0; j < fieldCount; j++) {
-          row[headers[j]] = parseCsvValue(fields[j], {
-            trim,
-            parseNumbers,
-            parseBooleans
-          });
-        }
-
-        // Предупреждение о лишних полях
-        const isDev = typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'development';
-        if (fields.length > headers.length && warnExtraFields && isDev) {
-          console.warn(`[jtcsv] Line ${i + 1}: ${fields.length - headers.length} extra fields ignored`);
-        }
-        result.push(row);
-      } catch (error) {
-        if (error instanceof ParsingError) {
-          throw new ParsingError(`Line ${i + 1}: ${error.message}`, i + 1);
+    if (options?.normalizeQuotes !== undefined && typeof options.normalizeQuotes !== 'boolean') {
+        throw new ConfigurationError('normalizeQuotes 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;
         }
-        throw error;
-      }
-    }
-    return result;
-  }, 'PARSE_FAILED', {
-    function: 'csvToJson'
-  });
-}
-async function* csvToJsonIterator(input, options = {}) {
-  const opts = options && typeof options === 'object' ? options : {};
-  validateCsvOptions(opts);
-  if (typeof input === 'string') {
-    const rows = csvToJson(input, options);
-    for (const row of rows) {
-      yield row;
-    }
-    return;
-  }
-  const {
-    delimiter,
-    autoDetect = true,
-    candidates = [';', ',', '\t', '|'],
-    hasHeaders = true,
-    renameMap = {},
-    trim = true,
-    parseNumbers = false,
-    parseBooleans = false,
-    maxRows
-  } = opts;
-  const stream = input instanceof Blob && input.stream ? input.stream() : input;
-  if (!stream || typeof stream.getReader !== 'function') {
-    throw new ValidationError('Input must be a CSV string, Blob/File, or ReadableStream');
-  }
-  const reader = stream.getReader();
-  const decoder = new TextDecoder('utf-8');
-  let buffer = '';
-  let insideQuotes = false;
-  let headers = null;
-  let rowCount = 0;
-  let lineNumber = 0;
-  let finalDelimiter = delimiter;
-  let delimiterResolved = Boolean(finalDelimiter);
-  const processFields = fields => {
-    if (fields.length === 1 && fields[0].trim() === '') {
-      return null;
-    }
-    rowCount++;
-    if (maxRows && rowCount > maxRows) {
-      throw new LimitError(`CSV size exceeds maximum limit of ${maxRows} rows`, maxRows, rowCount);
-    }
-    const row = {};
-    const fieldCount = Math.min(fields.length, headers.length);
-    for (let j = 0; j < fieldCount; j++) {
-      row[headers[j]] = parseCsvValue(fields[j], {
-        trim,
-        parseNumbers,
-        parseBooleans
-      });
-    }
-    return row;
-  };
-  const processLine = line => {
-    lineNumber++;
-    let cleanLine = line;
-    if (cleanLine.endsWith('\r')) {
-      cleanLine = cleanLine.slice(0, -1);
-    }
-    if (!delimiterResolved) {
-      if (!finalDelimiter && autoDetect) {
-        finalDelimiter = autoDetectDelimiter(cleanLine, candidates);
-      }
-      finalDelimiter = finalDelimiter || ';';
-      delimiterResolved = true;
-    }
-    if (cleanLine.trim() === '') {
-      return null;
-    }
-    if (!headers) {
-      if (hasHeaders) {
-        headers = parseCsvLine(cleanLine, lineNumber, finalDelimiter).map(header => {
-          const trimmed = trim ? header.trim() : header;
-          return renameMap[trimmed] || trimmed;
-        });
-        return null;
-      }
-      const fields = parseCsvLine(cleanLine, lineNumber, finalDelimiter);
-      headers = fields.map((_, index) => `column${index + 1}`);
-      return processFields(fields);
-    }
-    const fields = parseCsvLine(cleanLine, lineNumber, finalDelimiter);
-    return processFields(fields);
-  };
-  while (true) {
-    const {
-      value,
-      done
-    } = await reader.read();
-    if (done) {
-      break;
-    }
-    buffer += decoder.decode(value, {
-      stream: true
-    });
-    let start = 0;
-    for (let i = 0; i < buffer.length; i++) {
-      const char = buffer[i];
-      if (char === '"') {
-        if (insideQuotes && buffer[i + 1] === '"') {
-          i++;
-          continue;
-        }
-        insideQuotes = !insideQuotes;
-        continue;
-      }
-      if (char === '\n' && !insideQuotes) {
-        const line = buffer.slice(start, i);
-        start = i + 1;
-        const row = processLine(line);
-        if (row) {
-          yield row;
-        }
-      }
-    }
-    buffer = buffer.slice(start);
-  }
-  if (buffer.length > 0) {
-    const row = processLine(buffer);
-    if (row) {
-      yield row;
-    }
-  }
-  if (insideQuotes) {
-    throw new ParsingError('Unclosed quotes in CSV', lineNumber);
-  }
+    }
+    return bestCandidate;
 }
-
-// Экспорт для Node.js совместимости
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = {
-    csvToJson,
-    autoDetectDelimiter,
-    csvToJsonIterator
-  };
+function isEmptyValue(value) {
+    return value === undefined || value === null || value === '';
 }
-
-const DEFAULT_MAX_CHUNK_SIZE = 64 * 1024;
-function isReadableStream(value) {
-  return value && typeof value.getReader === 'function';
+function hasOddQuotes(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    let count = 0;
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === '"') {
+            count++;
+        }
+    }
+    return count % 2 === 1;
 }
-function isAsyncIterable(value) {
-  return value && typeof value[Symbol.asyncIterator] === 'function';
+function hasAnyQuotes(value) {
+    return typeof value === 'string' && value.includes('"');
 }
-function isIterable(value) {
-  return value && typeof value[Symbol.iterator] === 'function';
+function normalizeQuotesInField$1(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+    // Проверяем, выглядит ли значение как JSON (объект или массив)
+    if ((value.startsWith('{') && value.endsWith('}')) ||
+        (value.startsWith('[') && value.endsWith(']'))) {
+        return value; // Возвращаем как есть для JSON
+    }
+    let normalized = value.replace(/"{2,}/g, '"');
+    // Убираем правило, которое ломает JSON: не заменяем "," на ","
+    // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+    normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+    if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+        normalized = normalized.slice(1, -1);
+    }
+    return normalized;
 }
-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 normalizePhoneValue$1(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return trimmed;
+    }
+    return trimmed.replace(/["'\\]/g, '');
 }
-function detectInputFormat(input, options) {
-  if (options && options.inputFormat) {
-    return options.inputFormat;
-  }
-  if (typeof input === 'string') {
-    const trimmed = input.trim();
-    if (trimmed.startsWith('[')) {
-      return 'json-array';
-    }
-    if (trimmed.includes('\n')) {
-      return 'ndjson';
-    }
-    return 'json-array';
-  }
-  if (input instanceof Blob || isReadableStream(input)) {
-    return 'ndjson';
-  }
-  return 'json-array';
-}
-async function* parseNdjsonText(text) {
-  const lines = text.split(/\r?\n/);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    yield JSON.parse(trimmed);
-  }
-}
-async function* parseNdjsonStream(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder('utf-8');
-  let buffer = '';
-  while (true) {
-    const {
-      value,
-      done
-    } = await reader.read();
-    if (done) {
-      break;
-    }
-    buffer += decoder.decode(value, {
-      stream: true
+function normalizeRowQuotes(row, headers) {
+    const normalized = {};
+    const phoneKeys = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+    for (const header of headers) {
+        const baseValue = normalizeQuotesInField$1(row[header]);
+        if (phoneKeys.has(String(header).toLowerCase())) {
+            normalized[header] = normalizePhoneValue$1(baseValue);
+        }
+        else {
+            normalized[header] = baseValue;
+        }
+    }
+    return normalized;
+}
+function looksLikeUserAgent(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    return /Mozilla\/|Opera\/|MSIE|AppleWebKit|Gecko|Safari|Chrome\//.test(value);
+}
+function isHexColor(value) {
+    return typeof value === 'string' && /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
+}
+function repairShiftedRows(rows, headers, options = {}) {
+    if (!Array.isArray(rows) || rows.length === 0 || headers.length === 0) {
+        return rows;
+    }
+    const headerCount = headers.length;
+    const merged = [];
+    let index = 0;
+    while (index < rows.length) {
+        const row = rows[index];
+        if (!row || typeof row !== 'object') {
+            merged.push(row);
+            index++;
+            continue;
+        }
+        const values = headers.map((header) => row[header]);
+        let lastNonEmpty = -1;
+        for (let i = headerCount - 1; i >= 0; i--) {
+            if (!isEmptyValue(values[i])) {
+                lastNonEmpty = i;
+                break;
+            }
+        }
+        const missingCount = headerCount - 1 - lastNonEmpty;
+        if (lastNonEmpty >= 0 && missingCount > 0 && index + 1 < rows.length) {
+            const nextRow = rows[index + 1];
+            if (nextRow && typeof nextRow === 'object') {
+                const nextValues = headers.map((header) => nextRow[header]);
+                const nextTrailingEmpty = nextValues
+                    .slice(headerCount - missingCount)
+                    .every((value) => isEmptyValue(value));
+                const leadValues = nextValues
+                    .slice(0, missingCount)
+                    .filter((value) => !isEmptyValue(value));
+                const shouldMerge = nextTrailingEmpty
+                    && leadValues.length > 0
+                    && (hasOddQuotes(values[lastNonEmpty]) || hasAnyQuotes(values[lastNonEmpty]));
+                if (shouldMerge) {
+                    const toAppend = leadValues.map((value) => String(value));
+                    if (toAppend.length > 0) {
+                        const base = isEmptyValue(values[lastNonEmpty]) ? '' : String(values[lastNonEmpty]);
+                        values[lastNonEmpty] = base ? `${base}\n${toAppend.join('\n')}` : toAppend.join('\n');
+                    }
+                    for (let i = 0; i < missingCount; i++) {
+                        values[lastNonEmpty + 1 + i] = nextValues[missingCount + i];
+                    }
+                    const mergedRow = {};
+                    for (let i = 0; i < headerCount; i++) {
+                        mergedRow[headers[i]] = values[i];
+                    }
+                    merged.push(mergedRow);
+                    index += 2;
+                    continue;
+                }
+            }
+        }
+        if (index + 1 < rows.length && headerCount >= 6) {
+            const nextRow = rows[index + 1];
+            if (nextRow && typeof nextRow === 'object') {
+                const nextHex = nextRow[headers[4]];
+                const nextUserAgentHead = nextRow[headers[2]];
+                const nextUserAgentTail = nextRow[headers[3]];
+                const shouldMergeUserAgent = isEmptyValue(values[4])
+                    && isEmptyValue(values[5])
+                    && isHexColor(nextHex)
+                    && (looksLikeUserAgent(nextUserAgentHead) || looksLikeUserAgent(nextUserAgentTail));
+                if (shouldMergeUserAgent) {
+                    const addressParts = [values[3], nextRow[headers[0]], nextRow[headers[1]]]
+                        .filter((value) => !isEmptyValue(value))
+                        .map((value) => String(value));
+                    values[3] = addressParts.join('\n');
+                    const uaHead = isEmptyValue(nextUserAgentHead) ? '' : String(nextUserAgentHead);
+                    const uaTail = isEmptyValue(nextUserAgentTail) ? '' : String(nextUserAgentTail);
+                    const joiner = uaHead && uaTail ? (uaTail.startsWith(' ') ? '' : ',') : '';
+                    values[4] = uaHead + joiner + uaTail;
+                    values[5] = String(nextHex);
+                    const mergedRow = {};
+                    for (let i = 0; i < headerCount; i++) {
+                        mergedRow[headers[i]] = values[i];
+                    }
+                    merged.push(mergedRow);
+                    index += 2;
+                    continue;
+                }
+            }
+        }
+        merged.push(row);
+        index++;
+    }
+    if (options.normalizeQuotes) {
+        return merged.map((row) => normalizeRowQuotes(row, headers));
+    }
+    return merged;
+}
+/**
+ * Парсинг 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 { repairRowShifts = true, normalizeQuotes = true } = options || {};
+        // Ограничение количества строк
+        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);
+        }
+        if (repairRowShifts) {
+            return repairShiftedRows(result, headers, { normalizeQuotes });
+        }
+        if (normalizeQuotes) {
+            return result.map((row) => normalizeRowQuotes(row, headers));
+        }
+        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 { repairRowShifts = true, normalizeQuotes = true } = options || {};
+    // Ограничение количества строк
+    const maxRows = options.maxRows || Infinity;
+    const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
+    // Возврат данных по одной строке
+    const parsedRows = [];
+    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() : '';
+            // Try parsing numbers
+            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;
+            }
+        }
+        parsedRows.push(row);
+    }
+    const finalRows = repairRowShifts
+        ? repairShiftedRows(parsedRows, headers, { normalizeQuotes })
+        : (normalizeQuotes
+            ? parsedRows.map((row) => normalizeRowQuotes(row, headers))
+            : parsedRows);
+    for (const row of finalRows) {
+        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
+});
+
+const PHONE_KEYS = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+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();
+            }
+        }
     });
-    const lines = buffer.split(/\r?\n/);
-    buffer = lines.pop() || '';
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        continue;
-      }
-      yield JSON.parse(trimmed);
-    }
-  }
-  if (buffer.trim()) {
-    yield JSON.parse(buffer.trim());
-  }
-}
-async function* normalizeJsonInput(input, options = {}) {
-  const format = detectInputFormat(input, options);
-  if (Array.isArray(input)) {
-    for (const item of input) {
-      yield item;
-    }
-    return;
-  }
-  if (isAsyncIterable(input)) {
-    for await (const item of input) {
-      yield item;
-    }
-    return;
-  }
-  if (isIterable(input)) {
-    for (const item of input) {
-      yield item;
-    }
-    return;
-  }
-  if (typeof input === 'string') {
-    if (format === 'ndjson') {
-      yield* parseNdjsonText(input);
-      return;
-    }
-    const parsed = JSON.parse(input);
-    if (Array.isArray(parsed)) {
-      for (const item of parsed) {
-        yield item;
-      }
-      return;
-    }
-    yield parsed;
-    return;
-  }
-  if (input instanceof Blob) {
-    if (format === 'ndjson') {
-      yield* parseNdjsonStream(input.stream());
-      return;
-    }
-    const text = await input.text();
-    const parsed = JSON.parse(text);
-    if (Array.isArray(parsed)) {
-      for (const item of parsed) {
-        yield item;
-      }
-      return;
-    }
-    yield parsed;
-    return;
-  }
-  if (isReadableStream(input)) {
-    if (format !== 'ndjson') {
-      throw new ValidationError('ReadableStream input requires inputFormat="ndjson"');
-    }
-    yield* parseNdjsonStream(input);
-    return;
-  }
-  throw new ValidationError('Input must be an array, iterable, string, Blob, or ReadableStream');
-}
-function validateStreamOptions(options) {
-  if (options && typeof options !== 'object') {
-    throw new ConfigurationError('Options must be an object');
-  }
-  if (options !== null && options !== void 0 && options.delimiter && typeof options.delimiter !== 'string') {
-    throw new ConfigurationError('Delimiter must be a string');
-  }
-  if (options !== null && options !== void 0 && options.delimiter && options.delimiter.length !== 1) {
-    throw new ConfigurationError('Delimiter must be a single character');
-  }
-  if (options !== null && options !== void 0 && options.renameMap && typeof options.renameMap !== 'object') {
-    throw new ConfigurationError('renameMap must be an object');
-  }
-  if ((options === null || options === void 0 ? void 0 : options.maxRecords) !== undefined) {
-    if (typeof options.maxRecords !== 'number' || options.maxRecords <= 0) {
-      throw new ConfigurationError('maxRecords must be a positive number');
-    }
-  }
-}
-function escapeCsvValue(value, options) {
-  const {
-    delimiter,
-    preventCsvInjection = true,
-    rfc4180Compliant = true
-  } = options;
-  if (value === null || value === undefined || value === '') {
-    return '';
-  }
-  const stringValue = String(value);
-  let escapedValue = stringValue;
-  if (preventCsvInjection && /^[=+\-@]/.test(stringValue)) {
-    escapedValue = "'" + stringValue;
-  }
-  const needsQuoting = rfc4180Compliant ? escapedValue.includes(delimiter) || escapedValue.includes('"') || escapedValue.includes('\n') || escapedValue.includes('\r') : escapedValue.includes(delimiter) || escapedValue.includes('"') || escapedValue.includes('\n') || escapedValue.includes('\r');
-  if (needsQuoting) {
-    return `"${escapedValue.replace(/"/g, '""')}"`;
-  }
-  return escapedValue;
-}
-function buildHeaderState(keys, options) {
-  const renameMap = options.renameMap || {};
-  const template = options.template || {};
-  const originalKeys = Array.isArray(options.headers) ? options.headers : keys;
-  const headers = originalKeys.map(key => renameMap[key] || key);
-  const reverseRenameMap = {};
-  originalKeys.forEach((key, index) => {
-    reverseRenameMap[headers[index]] = key;
-  });
-  let finalHeaders = headers;
-  if (Object.keys(template).length > 0) {
-    const templateHeaders = Object.keys(template).map(key => renameMap[key] || key);
-    const extraHeaders = headers.filter(h => !templateHeaders.includes(h));
-    finalHeaders = [...templateHeaders, ...extraHeaders];
-  }
-  return {
-    headers: finalHeaders,
-    reverseRenameMap
-  };
+}
+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';
+}
+function normalizeQuotesInField(value) {
+    // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+    // Проверяем, выглядит ли значение как JSON (объект или массив)
+    if ((value.startsWith('{') && value.endsWith('}')) ||
+        (value.startsWith('[') && value.endsWith(']'))) {
+        return value; // Возвращаем как есть для JSON
+    }
+    let normalized = value.replace(/"{2,}/g, '"');
+    // Убираем правило, которое ломает JSON: не заменяем "," на ","
+    // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+    normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+    if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+        normalized = normalized.slice(1, -1);
+    }
+    return normalized;
+}
+function normalizePhoneValue(value) {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return trimmed;
+    }
+    return trimmed.replace(/["'\\]/g, '');
+}
+function normalizeValueForCsv(value, key, normalizeQuotes) {
+    if (!normalizeQuotes || typeof value !== 'string') {
+        return value;
+    }
+    const base = normalizeQuotesInField(value);
+    if (key && PHONE_KEYS.has(String(key).toLowerCase())) {
+        return normalizePhoneValue(base);
+    }
+    return base;
 }
 async function* jsonToCsvChunkIterator(input, options = {}) {
-  validateStreamOptions(options);
-  const opts = options && typeof options === 'object' ? options : {};
-  const {
-    delimiter = ';',
-    includeHeaders = true,
-    maxRecords,
-    maxChunkSize = DEFAULT_MAX_CHUNK_SIZE,
-    headerMode
-  } = opts;
-  let headerState = null;
-  let buffer = '';
-  let recordCount = 0;
-  const lineEnding = opts.rfc4180Compliant === false ? '\n' : '\r\n';
-  if (Array.isArray(input) && !opts.headers && (!headerMode || headerMode === 'all')) {
-    const allKeys = new Set();
-    for (const item of input) {
-      if (!item || typeof item !== 'object') {
-        continue;
-      }
-      Object.keys(item).forEach(key => allKeys.add(key));
-    }
-    headerState = buildHeaderState(Array.from(allKeys), opts);
-    if (includeHeaders && headerState.headers.length > 0) {
-      buffer += headerState.headers.join(delimiter) + lineEnding;
-    }
-  } else if (Array.isArray(opts.headers)) {
-    headerState = buildHeaderState(opts.headers, opts);
-    if (includeHeaders && headerState.headers.length > 0) {
-      buffer += headerState.headers.join(delimiter) + lineEnding;
-    }
-  }
-  for await (const item of normalizeJsonInput(input, opts)) {
-    if (!item || typeof item !== 'object') {
-      continue;
-    }
-    if (!headerState) {
-      headerState = buildHeaderState(Object.keys(item), opts);
-      if (includeHeaders && headerState.headers.length > 0) {
-        buffer += headerState.headers.join(delimiter) + lineEnding;
-      }
-    }
-    recordCount += 1;
-    if (maxRecords && recordCount > maxRecords) {
-      throw new LimitError(`Data size exceeds maximum limit of ${maxRecords} records`, maxRecords, recordCount);
-    }
-    const row = headerState.headers.map(header => {
-      const originalKey = headerState.reverseRenameMap[header] || header;
-      return escapeCsvValue(item[originalKey], {
-        delimiter,
-        preventCsvInjection: opts.preventCsvInjection !== false,
-        rfc4180Compliant: opts.rfc4180Compliant !== false
-      });
-    }).join(delimiter);
-    buffer += row + lineEnding;
-    if (buffer.length >= maxChunkSize) {
-      yield buffer;
-      buffer = '';
-    }
-  }
-  if (buffer.length > 0) {
-    yield buffer;
-  }
+    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;
+    const normalizeQuotes = options.normalizeQuotes !== false;
+    const isPotentialFormula = (input) => {
+        let idx = 0;
+        while (idx < input.length) {
+            const code = input.charCodeAt(idx);
+            if (code === 32 || code === 9 || code === 10 || code === 13 || code === 0xfeff) {
+                idx++;
+                continue;
+            }
+            break;
+        }
+        if (idx < input.length && (input[idx] === '"' || input[idx] === "'")) {
+            idx++;
+            while (idx < input.length) {
+                const code = input.charCodeAt(idx);
+                if (code === 32 || code === 9) {
+                    idx++;
+                    continue;
+                }
+                break;
+            }
+        }
+        if (idx >= input.length) {
+            return false;
+        }
+        const char = input[idx];
+        return char === '=' || char === '+' || char === '-' || char === '@';
+    };
+    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 && isPotentialFormula(escaped) ? `'${escaped}` : escaped;
+                }).join(delimiter);
+                yield headerLine + '\n';
+            }
+            isFirstChunk = false;
+        }
+        const row = headers.map(header => {
+            const value = item[header];
+            const normalized = normalizeValueForCsv(value, header, normalizeQuotes);
+            const strValue = normalized === null || normalized === undefined ? '' : String(normalized);
+            if (strValue.includes('"') || strValue.includes('\n') || strValue.includes('\r') || strValue.includes(delimiter)) {
+                return `"${strValue.replace(/"/g, '""')}"`;
+            }
+            if (preventInjection && isPotentialFormula(strValue)) {
+                return `'${strValue}`;
+            }
+            return strValue;
+        }).join(delimiter);
+        yield row + '\n';
+    }
 }
 async function* jsonToNdjsonChunkIterator(input, options = {}) {
-  validateStreamOptions(options);
-  for await (const item of normalizeJsonInput(input, options)) {
-    if (item === undefined) {
-      continue;
+    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';
     }
-    yield JSON.stringify(item) + '\n';
-  }
 }
 async function* csvToJsonChunkIterator(input, options = {}) {
-  const outputFormat = options.outputFormat || 'ndjson';
-  const asArray = outputFormat === 'json-array' || outputFormat === 'array' || outputFormat === 'json';
-  let first = true;
-  if (asArray) {
-    yield '[';
-  }
-  for await (const row of csvToJsonIterator(input, options)) {
-    const payload = JSON.stringify(row);
-    if (asArray) {
-      yield (first ? '' : ',') + payload;
-    } else {
-      yield payload + '\n';
-    }
-    first = false;
-  }
-  if (asArray) {
-    yield ']';
-  }
-}
-function jsonToCsvStream(input, options = {}) {
-  const iterator = jsonToCsvChunkIterator(input, options);
-  return createReadableStreamFromIterator(iterator);
-}
-function jsonToNdjsonStream(input, options = {}) {
-  const iterator = jsonToNdjsonChunkIterator(input, options);
-  return createReadableStreamFromIterator(iterator);
-}
-function csvToJsonStream(input, options = {}) {
-  const iterator = csvToJsonChunkIterator(input, options);
-  return createReadableStreamFromIterator(iterator);
+    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,
-    jsonToNdjsonStream,
-    csvToJsonStream
-  };
+    module.exports = {
+        jsonToCsvStream: jsonToCsvStream$1,
+        jsonToCsvStreamAsync,
+        jsonToNdjsonStream: jsonToNdjsonStream$1,
+        jsonToNdjsonStreamAsync,
+        csvToJsonStream: csvToJsonStream$1,
+        csvToJsonStreamAsync,
+        createReadableStreamFromIterator
+    };
 }
 
 // Браузерные специфичные функции для jtcsv
 // Функции, которые работают только в браузере
-
-
 /**
  * Скачивает JSON данные как CSV файл
- * 
- * @param {Array<Object>} data - Массив объектов для конвертации
- * @param {string} [filename='data.csv'] - Имя файла для скачивания
- * @param {Object} [options] - Опции для jsonToCsv
- * @returns {void}
- * 
+ *
+ * @param data - Массив объектов для конвертации
+ * @param filename - Имя файла для скачивания (по умолчанию 'data.csv')
+ * @param options - Опции для jsonToCsv
+ *
  * @example
  * const data = [
  *   { id: 1, name: 'John' },
@@ -1500,770 +1344,869 @@ if (typeof module !== 'undefined' && module.exports) {
  * 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(data, options);
-
-  // Создание Blob
-  const blob = new Blob([csv], {
-    type: 'text/csv;charset=utf-8;'
-  });
-
-  // Создание ссылки для скачивания
-  const link = document.createElement('a');
-
-  // Создание URL для Blob
-  const url = URL.createObjectURL(blob);
-
-  // Настройка ссылки
-  link.setAttribute('href', url);
-  link.setAttribute('download', filename);
-  link.style.visibility = 'hidden';
-
-  // Добавление в DOM и клик
-  document.body.appendChild(link);
-  link.click();
-
-  // Очистка
-  setTimeout(() => {
+    // Проверка что мы в браузере
+    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.revokeObjectURL(url);
-  }, 100);
+    // Освобождение URL
+    setTimeout(() => URL.revokeObjectURL(url), 100);
 }
-
 /**
- * Парсит CSV файл из input[type="file"] в JSON
- * 
- * @param {File} file - File объект из input
- * @param {Object} [options] - Опции для csvToJson
- * @returns {Promise<Array<Object>>} Promise с JSON данными
- * 
- * @example
- * // HTML: <input type="file" id="csvFile" accept=".csv">
- * const fileInput = document.getElementById('csvFile');
- * const json = await parseCsvFile(fileInput.files[0], { delimiter: ',' });
+ * Асинхронная версия 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 (typeof window === 'undefined') {
-    throw new ValidationError('parseCsvFile() работает только в браузере. Используйте readCsvAsJson() в Node.js');
-  }
-
-  // Валидация файла
-  if (!(file instanceof File)) {
-    throw new ValidationError('Input must be a File object');
-  }
-
-  // Проверка расширения файла
-  if (!file.name.toLowerCase().endsWith('.csv')) {
-    throw new ValidationError('File must have .csv extension');
-  }
-
-  // Проверка размера файла (предупреждение для больших файлов)
-  const MAX_SIZE_WARNING = 50 * 1024 * 1024; // 50MB
-  if (file.size > MAX_SIZE_WARNING && process.env.NODE_ENV !== 'production') {
-    console.warn(`⚠️ Warning: Processing large file (${(file.size / 1024 / 1024).toFixed(2)}MB).\n` + '💡 Consider using Web Workers for better performance.\n' + '🔧 Tip: Use parseCSVWithWorker() for files > 10MB.');
-  }
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = function (event) {
-      try {
-        const csvText = event.target.result;
-        const json = csvToJson(csvText, options);
-        resolve(json);
-      } catch (error) {
-        reject(error);
-      }
-    };
-    reader.onerror = function () {
-      reject(new ValidationError('Ошибка чтения файла'));
-    };
-    reader.onabort = function () {
-      reject(new ValidationError('Чтение файла прервано'));
-    };
-
-    // Чтение как текст
-    reader.readAsText(file, 'UTF-8');
-  });
+    if (!(file instanceof File)) {
+        throw new ValidationError('parseCsvFile() ожидает объект File');
+    }
+    // Чтение файла как текст
+    const text = await file.text();
+    // Парсинг CSV
+    return csvToJson$1(text, options);
 }
-
 /**
- * Stream CSV file as async iterator without full buffering.
+ * Парсит CSV файл потоково
  *
- * @param {File} file - File selected from input
- * @param {Object} [options] - csvToJson options
- * @returns {AsyncGenerator<Object>} Async iterator of rows
+ * @param file - File объект
+ * @param options - Опции для потокового парсинга
+ * @returns AsyncIterator с данными
  */
 function parseCsvFileStream(file, options = {}) {
-  if (typeof window === 'undefined') {
-    throw new ValidationError('parseCsvFileStream() is browser-only. Use readCsvAsJson() in Node.js');
-  }
-  if (!(file instanceof File)) {
-    throw new ValidationError('Input must be a File object');
-  }
-  if (!file.name.toLowerCase().endsWith('.csv')) {
-    throw new ValidationError('File must have .csv extension');
-  }
-  return csvToJsonIterator(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 {Array<Object>} data - Массив объектов
- * @param {Object} [options] - Опции для jsonToCsv
- * @returns {Blob} CSV Blob
+ *
+ * @param data - Массив объектов
+ * @param options - Опции для jsonToCsv
+ * @returns CSV Blob
  */
 function createCsvBlob(data, options = {}) {
-  const csv = jsonToCsv(data, options);
-  return new Blob([csv], {
-    type: 'text/csv;charset=utf-8;'
-  });
+    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} blob - CSV Blob
- * @param {Object} [options] - Опции для csvToJson
- * @returns {Promise<Array<Object>>} Promise с JSON данными
+ *
+ * @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(csvText, options);
-        resolve(json);
-      } catch (error) {
-        reject(error);
-      }
-    };
-    reader.onerror = function () {
-      reject(new ValidationError('Ошибка чтения Blob'));
-    };
-    reader.readAsText(blob, 'UTF-8');
-  });
+    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,
-    parseCsvFile,
-    parseCsvFileStream,
-    createCsvBlob,
-    parseCsvBlob,
-    jsonToCsvStream,
-    jsonToNdjsonStream,
-    csvToJsonStream
-  };
+    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 (!(value instanceof ArrayBuffer)) {
+        return false;
     }
-    if (isTransferableBuffer(value)) {
-      transferables.push(value);
-      return;
+    if (typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer) {
+        return false;
     }
-    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;
+    return true;
 }
-
-/**
- * Опции для 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 (мс)
+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 - Неудачные задачи
+/**
+ * Статистика 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 - Скорость обработки (элементов/сек)
+/**
+ * Прогресс обработки задачи
+ * @typedef {Object} TaskProgress
+ * @property {number} processed - Обработано элементов
+ * @property {number} total - Всего элементов
+ * @property {number} percentage - Процент выполнения
+ * @property {number} speed - Скорость обработки (элементов/сек)
  */
-
-/**
- * Worker Pool для параллельной обработки CSV
+/**
+ * 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
-        });
-      }
+    /**
+     * Создает новый 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();
     }
-  }
-
-  /**
-   * Обработка результата задачи
-   * @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();
+    /**
+     * Инициализация workers
+     * @private
+     */
+    initializeWorkers() {
+        const { workerCount } = this.options;
+        for (let i = 0; i < workerCount; i++) {
+            this.createWorker();
+        }
+        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
+     */
+    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
-   */
-  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 {
+    /**
+     * Обработка сообщений от 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.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);
-      }
+        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);
+        }
     }
-  }
-
-  /**
-   * Выполнение задачи на 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
+        };
     }
-  }
-
-  /**
-   * Обработка очереди задач
-   * @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<any>} Результат выполнения
-   */
-  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
+/**
+ * Создает Worker Pool для обработки CSV
+ * @param {WorkerPoolOptions} [options] - Опции pool
+ * @returns {WorkerPool} Worker Pool
  */
 function createWorkerPool(options = {}) {
-  // Используем встроенный worker скрипт
-  const workerScript = new URL('./csv-parser.worker.js', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('jtcsv.cjs.js', document.baseURI).href))).href;
-  return new WorkerPool(workerScript, 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 данные
+/**
+ * Парсит 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 если нужно
-  if (!parseCSVWithWorker.pool) {
-    parseCSVWithWorker.pool = createWorkerPool();
-  }
-  const pool = parseCSVWithWorker.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);
+    // Создание 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
+/**
+ * Чтение файла как текст
+ * @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);
-  });
+    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
-  };
+    module.exports = {
+        WorkerPool,
+        createWorkerPool,
+        parseCSVWithWorker
+    };
 }
 
 var workerPool = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  WorkerPool: WorkerPool,
-  createWorkerPool: createWorkerPool,
-  parseCSVWithWorker: parseCSVWithWorker
+    __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);
+    const mod = await Promise.resolve().then(function () { return workerPool; });
+    return mod.createWorkerPool(options);
 }
-async function parseCSVWithWorkerLazy(csvInput, options = {}, onProgress = null) {
-  const mod = await Promise.resolve().then(function () { return workerPool; });
-  return mod.parseCSVWithWorker(csvInput, options, onProgress);
+/**
+ * Ленивый парсинг 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,
-  // Error classes
-  ValidationError,
-  SecurityError,
-  FileSystemError,
-  ParsingError,
-  LimitError,
-  ConfigurationError,
-  ERROR_CODES,
-  // Удобные алиасы
-  parse: csvToJson,
-  unparse: jsonToCsv,
-  // Версия
-  version: '2.0.0-browser'
+    // 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;
+    // 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;
@@ -2274,20 +2217,25 @@ 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.cjs.js.map