jtcsv 2.2.8 → 3.1.0

package/dist/jtcsv.umd.js

@@ -1,2299 +1,2247 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jtcsv = {}));
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jtcsv = {}));
 })(this, (function (exports) { 'use strict';
 
-  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);
-      }
-    }
-  }
-
-  /**
-   * Ошибка валидации
-   */
-  class ValidationError extends JTCSVError {
-    constructor(message, details = {}) {
-      super(message, 'VALIDATION_ERROR', details);
-      this.name = 'ValidationError';
-    }
-  }
-
-  /**
-   * Ошибка безопасности
-   */
-  class SecurityError extends JTCSVError {
-    constructor(message, details = {}) {
-      super(message, 'SECURITY_ERROR', details);
-      this.name = 'SecurityError';
-    }
-  }
-
-  /**
-   * Ошибка файловой системы (адаптирована для браузера)
-   */
-  class FileSystemError extends JTCSVError {
-    constructor(message, originalError = null, 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;
-    }
-  }
-
-  /**
-   * Ошибка превышения лимита
-   */
-  class LimitError extends JTCSVError {
-    constructor(message, limit, actual, details = {}) {
-      super(message, 'LIMIT_ERROR', {
-        ...details,
-        limit,
-        actual
-      });
-      this.name = 'LimitError';
-      this.limit = limit;
-      this.actual = actual;
-    }
-  }
-
-  /**
-   * Ошибка конфигурации
-   */
-  class ConfigurationError extends JTCSVError {
-    constructor(message, details = {}) {
-      super(message, 'CONFIGURATION_ERROR', details);
-      this.name = 'ConfigurationError';
-    }
-  }
-  const ERROR_CODES = {
-    JTCSV_ERROR: 'JTCSV_ERROR',
-    VALIDATION_ERROR: 'VALIDATION_ERROR',
-    SECURITY_ERROR: 'SECURITY_ERROR',
-    FILE_SYSTEM_ERROR: 'FILE_SYSTEM_ERROR',
-    PARSING_ERROR: 'PARSING_ERROR',
-    LIMIT_ERROR: 'LIMIT_ERROR',
-    CONFIGURATION_ERROR: 'CONFIGURATION_ERROR',
-    INVALID_INPUT: 'INVALID_INPUT',
-    SECURITY_VIOLATION: 'SECURITY_VIOLATION',
-    FILE_NOT_FOUND: 'FILE_NOT_FOUND',
-    PARSE_FAILED: 'PARSE_FAILED',
-    SIZE_LIMIT: 'SIZE_LIMIT',
-    INVALID_CONFIG: 'INVALID_CONFIG',
-    UNKNOWN_ERROR: 'UNKNOWN_ERROR'
-  };
-
-  /**
-   * Безопасное выполнение функции с обработкой ошибок
-   * 
-   * @param {Function} fn - Функция для выполнения
-   * @param {string} errorCode - Код ошибки по умолчанию
-   * @param {Object} 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
-        });
-      }
-
-      // Сохранить оригинальный stack trace если возможно
-      if (error.stack) {
-        enhancedError.stack = error.stack;
-      }
-      throw enhancedError;
-    }
-  }
-
-  /**
-   * Асинхронная версия safeExecute
-   */
-  async function safeExecuteAsync(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
-    try {
-      if (typeof fn === 'function') {
-        return await fn();
-      }
-      throw new ValidationError('Function expected');
-    } catch (error) {
-      // Если ошибка уже является JTCSVError, перебросить её
-      if (error instanceof JTCSVError) {
-        throw error;
-      }
-
-      // Определить тип ошибки
-      let enhancedError;
-      const errorMessage = error.message || String(error);
-      if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
-        enhancedError = new ValidationError(errorMessage, {
-          ...errorDetails,
-          originalError: error
-        });
-      } else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
-        enhancedError = new SecurityError(errorMessage, {
-          ...errorDetails,
-          originalError: error
-        });
-      } else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
-        enhancedError = new ParsingError(errorMessage, 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;
-    }
-  }
-
-  // Экспорт для Node.js совместимости
-  if (typeof module !== 'undefined' && module.exports) {
-    module.exports = {
-      JTCSVError,
-      ValidationError,
-      SecurityError,
-      FileSystemError,
-      ParsingError,
-      LimitError,
-      ConfigurationError,
-      ERROR_CODES,
-      safeExecute,
-      safeExecuteAsync
-    };
-  }
-
-  // Браузерная версия 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');
+    // Система ошибок для браузерной версии 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;
+            this.hint = details.hint;
+            this.docs = details.docs;
+            this.context = details.context;
+            // Сохранение stack trace
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, JTCSVError);
+            }
+        }
     }
-
-    // Validate delimiter
-    if (options?.delimiter && typeof options.delimiter !== 'string') {
-      throw new ConfigurationError('Delimiter must be a string');
+    /**
+     * Ошибка валидации
+     */
+    class ValidationError extends JTCSVError {
+        constructor(message, details = {}) {
+            super(message, 'VALIDATION_ERROR', details);
+            this.name = 'ValidationError';
+        }
     }
-    if (options?.delimiter && options.delimiter.length !== 1) {
-      throw new ConfigurationError('Delimiter must be a single character');
+    /**
+     * Ошибка безопасности
+     */
+    class SecurityError extends JTCSVError {
+        constructor(message, details = {}) {
+            super(message, 'SECURITY_ERROR', details);
+            this.name = 'SecurityError';
+        }
     }
-
-    // Validate renameMap
-    if (options?.renameMap && typeof options.renameMap !== 'object') {
-      throw new ConfigurationError('renameMap must be an object');
+    /**
+     * Ошибка файловой системы (адаптирована для браузера)
+     */
+    class FileSystemError extends JTCSVError {
+        constructor(message, originalError, details = {}) {
+            super(message, 'FILE_SYSTEM_ERROR', { ...details, originalError });
+            this.name = 'FileSystemError';
+            if (originalError && originalError.code) {
+                this.code = originalError.code;
+            }
+        }
     }
-
-    // Validate maxRecords
-    if (options && options.maxRecords !== undefined) {
-      if (typeof options.maxRecords !== 'number' || options.maxRecords <= 0) {
-        throw new ConfigurationError('maxRecords must be a positive number');
-      }
+    /**
+     * Ошибка парсинга
+     */
+    class ParsingError extends JTCSVError {
+        constructor(message, lineNumber, details = {}) {
+            super(message, 'PARSING_ERROR', { ...details, lineNumber });
+            this.name = 'ParsingError';
+            this.lineNumber = lineNumber;
+        }
     }
-
-    // Validate preventCsvInjection
-    if (options?.preventCsvInjection !== undefined && typeof options.preventCsvInjection !== 'boolean') {
-      throw new ConfigurationError('preventCsvInjection must be a boolean');
+    /**
+     * Ошибка превышения лимита
+     */
+    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;
+        }
     }
-
-    // Validate rfc4180Compliant
-    if (options?.rfc4180Compliant !== undefined && typeof options.rfc4180Compliant !== 'boolean') {
-      throw new ConfigurationError('rfc4180Compliant must be a boolean');
+    /**
+     * Ошибка конфигурации
+     */
+    class ConfigurationError extends JTCSVError {
+        constructor(message, details = {}) {
+            super(message, 'CONFIGURATION_ERROR', details);
+            this.name = 'ConfigurationError';
+        }
     }
-    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 '';
-      }
-
-      // Предупреждение для больших наборов данных
-      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');
-      }
-
-      // Применение ограничения по количеству записей
-      if (maxRecords && data.length > maxRecords) {
-        throw new LimitError(`Data size exceeds maximum limit of ${maxRecords} records`, maxRecords, data.length);
-      }
-
-      // Получение всех уникальных ключей
-      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];
-      }
-
-      /**
-       * Экранирование значения для 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;
+    /**
+     * Коды ошибок
+     */
+    const ERROR_CODES = {
+        JTCSV_ERROR: 'JTCSV_ERROR',
+        VALIDATION_ERROR: 'VALIDATION_ERROR',
+        SECURITY_ERROR: 'SECURITY_ERROR',
+        FILE_SYSTEM_ERROR: 'FILE_SYSTEM_ERROR',
+        PARSING_ERROR: 'PARSING_ERROR',
+        LIMIT_ERROR: 'LIMIT_ERROR',
+        CONFIGURATION_ERROR: 'CONFIGURATION_ERROR',
+        INVALID_INPUT: 'INVALID_INPUT',
+        SECURITY_VIOLATION: 'SECURITY_VIOLATION',
+        FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+        PARSE_FAILED: 'PARSE_FAILED',
+        SIZE_LIMIT: 'SIZE_LIMIT',
+        INVALID_CONFIG: 'INVALID_CONFIG',
+        UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+    };
+    /**
+     * Безопасное выполнение функции с обработкой ошибок
+     *
+     * @param fn - Функция для выполнения
+     * @param errorCode - Код ошибки по умолчанию
+     * @param errorDetails - Детали ошибки
+     * @returns Результат выполнения функции
+     */
+    function safeExecute(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
+        try {
+            if (typeof fn === 'function') {
+                return fn();
+            }
+            throw new ValidationError('Function expected');
         }
-
-        // Соответствие 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, '""')}"`;
+        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;
         }
-        return escapedValue;
-      };
-
-      // Построение CSV строк
-      const rows = [];
-
-      // Добавление заголовков
-      if (includeHeaders && finalHeaders.length > 0) {
-        rows.push(finalHeaders.join(delimiter));
-      }
-
-      // Добавление данных
-      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);
-      }
-
-      // Разделители строк согласно RFC 4180
-      const lineEnding = rfc4180Compliant ? '\r\n' : '\n';
-      return rows.join(lineEnding);
-    }, 'PARSE_FAILED', {
-      function: 'jsonToCsv'
-    });
-  }
-
-  /**
-   * Глубокое разворачивание вложенных объектов и массивов
-   * 
-   * @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]';
-      }
-      visited.add(value);
+    /**
+     * Асинхронная версия safeExecute
+     */
+    async function safeExecuteAsync(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
+        try {
+            if (typeof fn === 'function') {
+                return await fn();
+            }
+            throw new ValidationError('Function expected');
+        }
+        catch (error) {
+            // Если ошибка уже является JTCSVError, перебросить её
+            if (error instanceof JTCSVError) {
+                throw error;
+            }
+            // Определить тип ошибки
+            let enhancedError;
+            const errorMessage = error.message || String(error);
+            if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
+                enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error });
+            }
+            else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
+                enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error });
+            }
+            else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
+                enhancedError = new ParsingError(errorMessage, undefined, { ...errorDetails, originalError: error });
+            }
+            else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
+                enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error });
+            }
+            else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
+                enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error });
+            }
+            else if (errorMessage.includes('file') || errorMessage.includes('File')) {
+                enhancedError = new FileSystemError(errorMessage, error, errorDetails);
+            }
+            else {
+                enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error });
+            }
+            if (error.stack) {
+                enhancedError.stack = error.stack;
+            }
+            throw enhancedError;
+        }
     }
-
-    // Обработка массивов
-    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(', ');
+    /**
+     * Создать сообщение об ошибке
+     */
+    function createErrorMessage(error, includeStack = false) {
+        let message = error.message || 'Unknown error';
+        if (error instanceof JTCSVError) {
+            message = `[${error.code}] ${message}`;
+            if (error instanceof ParsingError && error.lineNumber) {
+                message += ` (line ${error.lineNumber})`;
+            }
+            if (error instanceof LimitError && error.limit && error.actual) {
+                message += ` (limit: ${error.limit}, actual: ${error.actual})`;
+            }
+            if (error.hint) {
+                message += `\nHint: ${error.hint}`;
+            }
+            if (error.docs) {
+                message += `\nDocs: ${error.docs}`;
+            }
+        }
+        if (includeStack && error.stack) {
+            message += `\n${error.stack}`;
+        }
+        return message;
     }
-
-    // Обработка объектов
-    if (typeof value === 'object') {
-      const keys = Object.keys(value);
-      if (keys.length === 0) {
-        return '';
-      }
-      if (depth + 1 >= maxDepth) {
-        return '[Too Deep]';
-      }
-
-      // Сериализация сложных объектов
-      try {
-        return JSON.stringify(value);
-      } catch (error) {
-        if (error.message.includes('circular') || error.message.includes('Converting circular')) {
-          return '[Circular Reference]';
+    /**
+     * Обработка ошибки
+     */
+    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 '[Unstringifiable Object]';
-      }
+        return message;
+    }
+    // Экспорт для Node.js совместимости
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = {
+            JTCSVError,
+            ValidationError,
+            SecurityError,
+            FileSystemError,
+            ParsingError,
+            LimitError,
+            ConfigurationError,
+            ERROR_CODES,
+            safeExecute,
+            safeExecuteAsync,
+            createErrorMessage,
+            handleError
+        };
     }
 
-    // Примитивные значения
-    return String(value);
-  }
-
-  /**
-   * Предобработка 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;
-    });
-  }
-
-  // Экспорт для Node.js совместимости
-  if (typeof module !== 'undefined' && module.exports) {
-    module.exports = {
-      jsonToCsv,
-      preprocessData,
-      deepUnwrap
-    };
-  }
-
-  // Браузерная версия 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');
+    // Браузерная версия JSON to CSV конвертера
+    // Адаптирована для работы в браузере без Node.js API
+    /**
+     * Валидация входных данных и опций
+     * @private
+     */
+    function validateInput(data, options) {
+        // Validate data
+        if (!Array.isArray(data)) {
+            throw new ValidationError('Input data must be an array');
+        }
+        // Validate options
+        if (options && typeof options !== 'object') {
+            throw new ConfigurationError('Options must be an object');
+        }
+        // Validate delimiter
+        if (options?.delimiter && typeof options.delimiter !== 'string') {
+            throw new ConfigurationError('Delimiter must be a string');
+        }
+        if (options?.delimiter && options.delimiter.length !== 1) {
+            throw new ConfigurationError('Delimiter must be a single character');
+        }
+        // Validate renameMap
+        if (options?.renameMap && typeof options.renameMap !== 'object') {
+            throw new ConfigurationError('renameMap must be an object');
+        }
+        // Validate maxRecords
+        if (options && options.maxRecords !== undefined) {
+            if (typeof options.maxRecords !== 'number' || options.maxRecords <= 0) {
+                throw new ConfigurationError('maxRecords must be a positive number');
+            }
+        }
+        // Validate preventCsvInjection
+        if (options?.preventCsvInjection !== undefined && typeof options.preventCsvInjection !== 'boolean') {
+            throw new ConfigurationError('preventCsvInjection must be a boolean');
+        }
+        // Validate rfc4180Compliant
+        if (options?.rfc4180Compliant !== undefined && typeof options.rfc4180Compliant !== 'boolean') {
+            throw new ConfigurationError('rfc4180Compliant must be a boolean');
+        }
+        if (options?.normalizeQuotes !== undefined && typeof options.normalizeQuotes !== 'boolean') {
+            throw new ConfigurationError('normalizeQuotes must be a boolean');
+        }
+        return true;
     }
-
-    // Validate delimiter
-    if (options?.delimiter && typeof options.delimiter !== 'string') {
-      throw new ConfigurationError('Delimiter must be a string');
+    /**
+     * Экранирование CSV значений для предотвращения инъекций
+     * @private
+     */
+    function escapeCsvValue(value, preventInjection = true) {
+        if (value === null || value === undefined) {
+            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 (str.includes('"') || str.includes('\n') || str.includes('\r') || str.includes(',')) {
+            return '"' + str.replace(/"/g, '""') + '"';
+        }
+        return str;
+    }
+    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;
     }
-    if (options?.delimiter && options.delimiter.length !== 1) {
-      throw new ConfigurationError('Delimiter must be a single character');
+    function normalizePhoneValue$2(value) {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return trimmed;
+        }
+        return trimmed.replace(/["'\\]/g, '');
     }
-
-    // Validate autoDetect
-    if (options?.autoDetect !== undefined && typeof options.autoDetect !== 'boolean') {
-      throw new ConfigurationError('autoDetect must be a boolean');
+    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;
     }
-
-    // Validate candidates
-    if (options?.candidates && !Array.isArray(options.candidates)) {
-      throw new ConfigurationError('candidates must be an array');
+    /**
+     * Извлечение всех уникальных ключей из массива объектов
+     * @private
+     */
+    function extractAllKeys(data) {
+        const keys = new Set();
+        for (const item of data) {
+            if (item && typeof item === 'object') {
+                Object.keys(item).forEach(key => keys.add(key));
+            }
+        }
+        return Array.from(keys);
+    }
+    /**
+     * Конвертация массива объектов в CSV строку
+     *
+     * @param data - Массив объектов для конвертации
+     * @param options - Опции конвертации
+     * @returns CSV строка
+     */
+    function jsonToCsv$1(data, options = {}) {
+        return safeExecute(() => {
+            validateInput(data, options);
+            if (data.length === 0) {
+                return '';
+            }
+            // Настройки по умолчанию
+            const delimiter = options.delimiter || ';';
+            const includeHeaders = options.includeHeaders !== false;
+            const maxRecords = options.maxRecords || data.length;
+            const preventInjection = options.preventCsvInjection !== false;
+            const rfc4180Compliant = options.rfc4180Compliant !== false;
+            const 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');
+        });
     }
-
-    // Validate maxRows
-    if (options?.maxRows !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
-      throw new ConfigurationError('maxRows must be a positive number');
+    /**
+     * Асинхронная версия jsonToCsv
+     */
+    async function jsonToCsvAsync$1(data, options = {}) {
+        return jsonToCsv$1(data, options);
+    }
+    /**
+     * Создает итератор для потоковой конвертации JSON в CSV
+     *
+     * @param data - Массив объектов или async итератор
+     * @param options - Опции конвертации
+     * @returns AsyncIterator с CSV чанками
+     */
+    async function* jsonToCsvIterator(data, options = {}) {
+        validateInput(Array.isArray(data) ? data : [], options);
+        const delimiter = options.delimiter || ';';
+        const includeHeaders = options.includeHeaders !== false;
+        const preventInjection = options.preventCsvInjection !== false;
+        const rfc4180Compliant = options.rfc4180Compliant !== false;
+        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');
+            }
+        }
+        else {
+            // Для async итератора нужна другая логика
+            throw new ValidationError('Async iterators not yet implemented in browser version');
+        }
     }
-    if (options?.warnExtraFields !== undefined && typeof options.warnExtraFields !== 'boolean') {
-      throw new ConfigurationError('warnExtraFields must be a boolean');
+    /**
+     * Асинхронная версия jsonToCsvIterator (псевдоним)
+     */
+    const jsonToCsvIteratorAsync = jsonToCsvIterator;
+    /**
+     * Безопасная конвертация с обработкой ошибок
+     *
+     * @param data - Массив объектов
+     * @param options - Опции конвертации
+     * @returns CSV строка или null при ошибке
+     */
+    function jsonToCsvSafe(data, options = {}) {
+        try {
+            return jsonToCsv$1(data, options);
+        }
+        catch (error) {
+            console.error('JSON to CSV conversion error:', error);
+            return null;
+        }
     }
-    return true;
-  }
-
-  /**
-   * Валидация CSV ввода и опций
-   * @private
-   */
-  function validateCsvInput(csv, options) {
-    // Validate CSV input
-    if (typeof csv !== 'string') {
-      throw new ValidationError('Input must be a CSV string');
-    }
-    return validateCsvOptions(options);
-  }
-
-  /**
-   * Парсинг одной строки CSV с правильным экранированием
-   * @private
-   */
-  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;
+    /**
+     * Асинхронная версия jsonToCsvSafe
+     */
+    async function jsonToCsvSafeAsync(data, options = {}) {
+        try {
+            return await jsonToCsvAsync$1(data, options);
+        }
+        catch (error) {
+            console.error('JSON to CSV conversion error:', error);
+            return null;
+        }
     }
-
-    // Обработка незавершенного экранирования
-    if (escapeNext) {
-      currentField += '\\';
+    // Экспорт для Node.js совместимости
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = {
+            jsonToCsv: jsonToCsv$1,
+            jsonToCsvAsync: jsonToCsvAsync$1,
+            jsonToCsvIterator,
+            jsonToCsvIteratorAsync,
+            jsonToCsvSafe,
+            jsonToCsvSafeAsync
+        };
     }
 
-    // Добавление последнего поля
-    fields.push(currentField);
+    var jsonToCsvBrowser = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        jsonToCsv: jsonToCsv$1,
+        jsonToCsvAsync: jsonToCsvAsync$1,
+        jsonToCsvIterator: jsonToCsvIterator,
+        jsonToCsvIteratorAsync: jsonToCsvIteratorAsync,
+        jsonToCsvSafe: jsonToCsvSafe,
+        jsonToCsvSafeAsync: jsonToCsvSafeAsync
+    });
 
-    // Проверка незакрытых кавычек
-    if (insideQuotes) {
-      throw new ParsingError('Unclosed quotes in CSV', lineNumber);
+    // Браузерная версия CSV to JSON конвертера
+    // Адаптирована для работы в браузере без Node.js API
+    /**
+     * Валидация опций парсинга
+     * @private
+     */
+    function validateCsvOptions(options) {
+        // Validate options
+        if (options && typeof options !== 'object') {
+            throw new ConfigurationError('Options must be an object');
+        }
+        // Validate delimiter
+        if (options?.delimiter && typeof options.delimiter !== 'string') {
+            throw new ConfigurationError('Delimiter must be a string');
+        }
+        if (options?.delimiter && options.delimiter.length !== 1) {
+            throw new ConfigurationError('Delimiter must be a single character');
+        }
+        // Validate autoDetect
+        if (options?.autoDetect !== undefined && typeof options.autoDetect !== 'boolean') {
+            throw new ConfigurationError('autoDetect must be a boolean');
+        }
+        // Validate candidates
+        if (options?.candidates && !Array.isArray(options.candidates)) {
+            throw new ConfigurationError('candidates must be an array');
+        }
+        // Validate maxRows
+        if (options?.maxRows !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
+            throw new ConfigurationError('maxRows must be a positive number');
+        }
+        if (options?.warnExtraFields !== undefined && typeof options.warnExtraFields !== 'boolean') {
+            throw new ConfigurationError('warnExtraFields must be a boolean');
+        }
+        if (options?.repairRowShifts !== undefined && typeof options.repairRowShifts !== 'boolean') {
+            throw new ConfigurationError('repairRowShifts must be a boolean');
+        }
+        if (options?.normalizeQuotes !== undefined && typeof options.normalizeQuotes !== 'boolean') {
+            throw new ConfigurationError('normalizeQuotes must be a boolean');
+        }
+        return true;
     }
-
-    // Валидация количества полей
-    if (fields.length === 0) {
-      throw new ParsingError('No fields found', lineNumber);
+    /**
+     * Автоматическое определение разделителя
+     * @private
+     */
+    function autoDetectDelimiter$1(text, candidates = [',', ';', '\t', '|']) {
+        if (!text || typeof text !== 'string') {
+            return ',';
+        }
+        const firstLine = text.split('\n')[0];
+        if (!firstLine) {
+            return ',';
+        }
+        let bestCandidate = ',';
+        let bestCount = 0;
+        for (const candidate of candidates) {
+            const count = (firstLine.match(new RegExp(candidate.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
+            if (count > bestCount) {
+                bestCount = count;
+                bestCandidate = candidate;
+            }
+        }
+        return bestCandidate;
     }
-    return fields;
-  }
-
-  /**
-   * Парсинг значения на основе опций
-   * @private
-   */
-  function parseCsvValue(value, options) {
-    const {
-      trim = true,
-      parseNumbers = false,
-      parseBooleans = false
-    } = options;
-    let result = value;
-    if (trim) {
-      result = result.trim();
+    function isEmptyValue(value) {
+        return value === undefined || value === null || value === '';
     }
-
-    // Удаление защиты формул Excel
-    if (result.startsWith("'")) {
-      result = result.substring(1);
+    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;
     }
-
-    // Парсинг чисел
-    if (parseNumbers && /^-?\d+(\.\d+)?$/.test(result)) {
-      const num = parseFloat(result);
-      if (!isNaN(num)) {
-        return num;
-      }
+    function hasAnyQuotes(value) {
+        return typeof value === 'string' && value.includes('"');
     }
-
-    // Парсинг булевых значений
-    if (parseBooleans) {
-      const lowerValue = result.toLowerCase();
-      if (lowerValue === 'true') {
-        return true;
-      }
-      if (lowerValue === 'false') {
-        return false;
-      }
+    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;
     }
-
-    // Пустые строки как 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 ';'; // значение по умолчанию
+    function normalizePhoneValue$1(value) {
+        if (typeof value !== 'string') {
+            return value;
+        }
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return trimmed;
+        }
+        return trimmed.replace(/["'\\]/g, '');
+    }
+    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;
     }
-
-    // Использование первой непустой строки для определения
-    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;
-      }
+    function looksLikeUserAgent(value) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        return /Mozilla\/|Opera\/|MSIE|AppleWebKit|Gecko|Safari|Chrome\//.test(value);
     }
-
-    // Если разделитель не найден или ничья
-    if (maxCount === 0) {
-      return ';'; // значение по умолчанию
+    function isHexColor(value) {
+        return typeof value === 'string' && /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
     }
-    return detectedDelimiter;
-  }
-
-  /**
-   * Конвертирует 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;
-
-      // Определение разделителя
-      let finalDelimiter = delimiter;
-      if (!finalDelimiter && autoDetect) {
-        finalDelimiter = autoDetectDelimiter(csv, candidates);
-      }
-      finalDelimiter = finalDelimiter || ';'; // fallback
-
-      // Обработка пустого CSV
-      if (csv.trim() === '') {
-        return [];
-      }
-      if (isSimpleCsv(csv)) {
-        return parseSimpleCsv(csv, finalDelimiter, {
-          hasHeaders,
-          renameMap,
-          trim,
-          parseNumbers,
-          parseBooleans,
-          maxRows
-        });
-      }
-
-      // Парсинг 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 (currentLine !== '' || insideQuotes) {
-        lines.push(currentLine);
-      }
-      if (lines.length === 0) {
-        return [];
-      }
-
-      // Предупреждение для больших наборов данных
-      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');
-      }
-
-      // Применение ограничения по строкам
-      if (maxRows && lines.length > maxRows) {
-        throw new LimitError(`CSV size exceeds maximum limit of ${maxRows} rows`, maxRows, lines.length);
-      }
-      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;
-        }
-      }
-
-      // Парсинг строк данных
-      const result = [];
-      for (let i = startIndex; i < lines.length; i++) {
-        const line = lines[i];
-
-        // Пропуск пустых строк
-        if (line.trim() === '') {
-          continue;
+    function repairShiftedRows(rows, headers, options = {}) {
+        if (!Array.isArray(rows) || rows.length === 0 || headers.length === 0) {
+            return rows;
         }
-        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);
-          }
-          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
+        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;
         });
-      }
-      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) {
+    }
+    /**
+     * Асинхронная версия 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;
-          }
         }
-      }
-      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);
     }
-  }
-
-  // Экспорт для Node.js совместимости
-  if (typeof module !== 'undefined' && module.exports) {
-    module.exports = {
-      csvToJson,
-      autoDetectDelimiter,
-      csvToJsonIterator
-    };
-  }
-
-  const DEFAULT_MAX_CHUNK_SIZE = 64 * 1024;
-  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) {
+    /**
+     * Асинхронная версия csvToJsonIterator (псевдоним)
+     */
+    const csvToJsonIteratorAsync = csvToJsonIterator$1;
+    /**
+     * Парсинг CSV с обработкой ошибок
+     *
+     * @param csvText - CSV текст
+     * @param options - Опции парсинга
+     * @returns Результат парсинга или null при ошибке
+     */
+    function parseCsvSafe(csvText, options = {}) {
         try {
-          const {
-            value,
-            done
-          } = await iterator.next();
-          if (done) {
-            controller.close();
-            return;
-          }
-          controller.enqueue(value);
-        } catch (error) {
-          controller.error(error);
+            return csvToJson$1(csvText, options);
         }
-      },
-      cancel() {
-        if (iterator.return) {
-          iterator.return();
+        catch (error) {
+            console.error('CSV parsing error:', error);
+            return null;
         }
-      }
-    });
-  }
-  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
-      });
-      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?.delimiter && typeof options.delimiter !== 'string') {
-      throw new ConfigurationError('Delimiter must be a string');
-    }
-    if (options?.delimiter && options.delimiter.length !== 1) {
-      throw new ConfigurationError('Delimiter must be a single character');
-    }
-    if (options?.renameMap && typeof options.renameMap !== 'object') {
-      throw new ConfigurationError('renameMap must be an object');
-    }
-    if (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
-    };
-  }
-  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;
-    }
-  }
-  async function* jsonToNdjsonChunkIterator(input, options = {}) {
-    validateStreamOptions(options);
-    for await (const item of normalizeJsonInput(input, options)) {
-      if (item === undefined) {
-        continue;
-      }
-      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 module !== 'undefined' && module.exports) {
-    module.exports = {
-      jsonToCsvStream,
-      jsonToNdjsonStream,
-      csvToJsonStream
-    };
-  }
-
-  // Браузерные специфичные функции для jtcsv
-  // Функции, которые работают только в браузере
-
-
-  /**
-   * Скачивает JSON данные как CSV файл
-   * 
-   * @param {Array<Object>} data - Массив объектов для конвертации
-   * @param {string} [filename='data.csv'] - Имя файла для скачивания
-   * @param {Object} [options] - Опции для jsonToCsv
-   * @returns {void}
-   * 
-   * @example
-   * const data = [
-   *   { id: 1, name: 'John' },
-   *   { id: 2, name: 'Jane' }
-   * ];
-   * downloadAsCsv(data, 'users.csv', { delimiter: ',' });
-   */
-  function downloadAsCsv(data, filename = 'data.csv', options = {}) {
-    // Проверка что мы в браузере
-    if (typeof window === 'undefined') {
-      throw new ValidationError('downloadAsCsv() работает только в браузере. Используйте saveAsCsv() в Node.js');
     }
-
-    // Валидация имени файла
-    if (typeof filename !== 'string' || filename.trim() === '') {
-      throw new ValidationError('Filename must be a non-empty string');
+    /**
+     * Асинхронная версия parseCsvSafe
+     */
+    async function parseCsvSafeAsync(csvText, options = {}) {
+        try {
+            return await csvToJsonAsync$1(csvText, options);
+        }
+        catch (error) {
+            console.error('CSV parsing error:', error);
+            return null;
+        }
     }
-
-    // Добавление расширения .csv если его нет
-    if (!filename.toLowerCase().endsWith('.csv')) {
-      filename += '.csv';
+    // Экспорт для 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
+        };
     }
 
-    // Конвертация в CSV
-    const csv = jsonToCsv(data, options);
-
-    // Создание Blob
-    const blob = new Blob([csv], {
-      type: 'text/csv;charset=utf-8;'
+    var csvToJsonBrowser = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        csvToJson: csvToJson$1,
+        csvToJsonAsync: csvToJsonAsync$1,
+        csvToJsonIterator: csvToJsonIterator$1,
+        csvToJsonIteratorAsync: csvToJsonIteratorAsync,
+        parseCsvSafe: parseCsvSafe,
+        parseCsvSafeAsync: parseCsvSafeAsync
     });
 
-    // Создание ссылки для скачивания
-    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(() => {
-      document.body.removeChild(link);
-      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: ',' });
-   */
-  async function parseCsvFile(file, options = {}) {
-    // Проверка что мы в браузере
-    if (typeof window === 'undefined') {
-      throw new ValidationError('parseCsvFile() работает только в браузере. Используйте readCsvAsJson() в Node.js');
+    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();
+                }
+            }
+        });
     }
-
-    // Валидация файла
-    if (!(file instanceof File)) {
-      throw new ValidationError('Input must be a File object');
+    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;
     }
-
-    // Проверка расширения файла
-    if (!file.name.toLowerCase().endsWith('.csv')) {
-      throw new ValidationError('File must have .csv extension');
+    function normalizePhoneValue(value) {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return trimmed;
+        }
+        return trimmed.replace(/["'\\]/g, '');
     }
-
-    // Проверка размера файла (предупреждение для больших файлов)
-    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');
-    });
-  }
-
-  /**
-   * Stream CSV file as async iterator without full buffering.
-   *
-   * @param {File} file - File selected from input
-   * @param {Object} [options] - csvToJson options
-   * @returns {AsyncGenerator<Object>} Async iterator of rows
-   */
-  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);
-  }
-
-  /**
-   * Создает CSV файл из JSON данных (альтернатива downloadAsCsv)
-   * Возвращает Blob вместо автоматического скачивания
-   * 
-   * @param {Array<Object>} data - Массив объектов
-   * @param {Object} [options] - Опции для jsonToCsv
-   * @returns {Blob} CSV Blob
-   */
-  function createCsvBlob(data, options = {}) {
-    const csv = jsonToCsv(data, options);
-    return new Blob([csv], {
-      type: 'text/csv;charset=utf-8;'
-    });
-  }
-
-  /**
-   * Парсит CSV строку из Blob
-   * 
-   * @param {Blob} blob - CSV Blob
-   * @param {Object} [options] - Опции для csvToJson
-   * @returns {Promise<Array<Object>>} 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');
-    });
-  }
-
-  // Экспорт для Node.js совместимости
-  if (typeof module !== 'undefined' && module.exports) {
-    module.exports = {
-      downloadAsCsv,
-      parseCsvFile,
-      parseCsvFileStream,
-      createCsvBlob,
-      parseCsvBlob,
-      jsonToCsvStream,
-      jsonToNdjsonStream,
-      csvToJsonStream
-    };
-  }
-
-  // Worker Pool для параллельной обработки CSV
-  // Использует Comlink для простой коммуникации с Web Workers
-
-
-  // Проверка поддержки Web Workers
-  const WORKERS_SUPPORTED = typeof Worker !== 'undefined';
-  function isTransferableBuffer(value) {
-    if (!(value instanceof ArrayBuffer)) {
-      return false;
-    }
-    if (typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer) {
-      return false;
-    }
-    return true;
-  }
-  function collectTransferables(args) {
-    const transferables = [];
-    const collectFromValue = value => {
-      if (!value) {
-        return;
-      }
-      if (isTransferableBuffer(value)) {
-        transferables.push(value);
-        return;
-      }
-      if (ArrayBuffer.isView(value) && isTransferableBuffer(value.buffer)) {
-        transferables.push(value.buffer);
-        return;
-      }
-      if (Array.isArray(value)) {
-        value.forEach(collectFromValue);
-      }
-    };
-    args.forEach(collectFromValue);
-    return transferables.length ? transferables : null;
-  }
-
-  /**
-   * Опции для Worker Pool
-   * @typedef {Object} WorkerPoolOptions
-   * @property {number} [workerCount=4] - Количество workers в pool
-   * @property {number} [maxQueueSize=100] - Максимальный размер очереди задач
-   * @property {boolean} [autoScale=true] - Автоматическое масштабирование pool
-   * @property {number} [idleTimeout=60000] - Таймаут простоя worker (мс)
-   */
-
-  /**
-   * Статистика Worker Pool
-   * @typedef {Object} WorkerPoolStats
-   * @property {number} totalWorkers - Всего workers
-   * @property {number} activeWorkers - Активные workers
-   * @property {number} idleWorkers - Простаивающие workers
-   * @property {number} queueSize - Размер очереди
-   * @property {number} tasksCompleted - Завершенные задачи
-   * @property {number} tasksFailed - Неудачные задачи
-   */
-
-  /**
-   * Прогресс обработки задачи
-   * @typedef {Object} TaskProgress
-   * @property {number} processed - Обработано элементов
-   * @property {number} total - Всего элементов
-   * @property {number} percentage - Процент выполнения
-   * @property {number} speed - Скорость обработки (элементов/сек)
-   */
-
-  /**
-   * Worker Pool для параллельной обработки CSV
-   */
-  class WorkerPool {
-    /**
-     * Создает новый Worker Pool
-     * @param {string} workerScript - URL скрипта worker
-     * @param {WorkerPoolOptions} [options] - Опции pool
-     */
-    constructor(workerScript, options = {}) {
-      if (!WORKERS_SUPPORTED) {
-        throw new ValidationError('Web Workers не поддерживаются в этом браузере');
-      }
-      this.workerScript = workerScript;
-      this.options = {
-        workerCount: 4,
-        maxQueueSize: 100,
-        autoScale: true,
-        idleTimeout: 60000,
-        ...options
-      };
-      this.workers = [];
-      this.taskQueue = [];
-      this.activeTasks = new Map();
-      this.stats = {
-        totalWorkers: 0,
-        activeWorkers: 0,
-        idleWorkers: 0,
-        queueSize: 0,
-        tasksCompleted: 0,
-        tasksFailed: 0
-      };
-      this.initializeWorkers();
+    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;
     }
-
-    /**
-     * Инициализация workers
-     * @private
-     */
-    initializeWorkers() {
-      const {
-        workerCount
-      } = this.options;
-      for (let i = 0; i < workerCount; i++) {
-        this.createWorker();
-      }
-      this.updateStats();
+    async function* jsonToCsvChunkIterator(input, options = {}) {
+        const format = detectInputFormat(input, options);
+        if (format === 'csv') {
+            throw new ValidationError('Input appears to be CSV, not JSON');
+        }
+        // Вспомогательная функция для создания асинхронного итератора
+        function toAsyncIterator(iterable) {
+            if (isAsyncIterable(iterable)) {
+                return iterable[Symbol.asyncIterator]();
+            }
+            if (isIterable(iterable)) {
+                const syncIterator = iterable[Symbol.iterator]();
+                return {
+                    next: () => Promise.resolve(syncIterator.next()),
+                    return: syncIterator.return ? () => Promise.resolve(syncIterator.return()) : undefined,
+                    throw: syncIterator.throw ? (error) => Promise.resolve(syncIterator.throw(error)) : undefined
+                };
+            }
+            throw new ValidationError('Input is not iterable');
+        }
+        let iterator;
+        if (isAsyncIterable(input) || isIterable(input)) {
+            iterator = toAsyncIterator(input);
+        }
+        else if (typeof input === 'string') {
+            const parsed = JSON.parse(input);
+            if (Array.isArray(parsed)) {
+                iterator = toAsyncIterator(parsed);
+            }
+            else {
+                iterator = toAsyncIterator([parsed]);
+            }
+        }
+        else if (Array.isArray(input)) {
+            iterator = toAsyncIterator(input);
+        }
+        else {
+            iterator = toAsyncIterator([input]);
+        }
+        const delimiter = options.delimiter || ';';
+        const includeHeaders = options.includeHeaders !== false;
+        const preventInjection = options.preventCsvInjection !== false;
+        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';
+        }
     }
-
-    /**
-     * Создает нового 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}`);
-      }
+    async function* jsonToNdjsonChunkIterator(input, options = {}) {
+        const format = detectInputFormat(input, options);
+        // Вспомогательная функция для создания асинхронного итератора
+        function toAsyncIterator(iterable) {
+            if (isAsyncIterable(iterable)) {
+                return iterable[Symbol.asyncIterator]();
+            }
+            if (isIterable(iterable)) {
+                const syncIterator = iterable[Symbol.iterator]();
+                return {
+                    next: () => Promise.resolve(syncIterator.next()),
+                    return: syncIterator.return ? () => Promise.resolve(syncIterator.return()) : undefined,
+                    throw: syncIterator.throw ? (error) => Promise.resolve(syncIterator.throw(error)) : undefined
+                };
+            }
+            throw new ValidationError('Input is not iterable');
+        }
+        let iterator;
+        if (isAsyncIterable(input) || isIterable(input)) {
+            iterator = toAsyncIterator(input);
+        }
+        else if (typeof input === 'string') {
+            if (format === 'ndjson') {
+                const lines = input.split('\n').filter(line => line.trim() !== '');
+                iterator = toAsyncIterator(lines);
+            }
+            else {
+                const parsed = JSON.parse(input);
+                if (Array.isArray(parsed)) {
+                    iterator = toAsyncIterator(parsed);
+                }
+                else {
+                    iterator = toAsyncIterator([parsed]);
+                }
+            }
+        }
+        else if (Array.isArray(input)) {
+            iterator = toAsyncIterator(input);
+        }
+        else {
+            iterator = toAsyncIterator([input]);
+        }
+        while (true) {
+            const { value, done } = await iterator.next();
+            if (done)
+                break;
+            let jsonStr;
+            if (typeof value === 'string') {
+                try {
+                    // Проверяем, является ли строка валидным JSON
+                    JSON.parse(value);
+                    jsonStr = value;
+                }
+                catch {
+                    // Если нет, сериализуем как JSON
+                    jsonStr = JSON.stringify(value);
+                }
+            }
+            else {
+                jsonStr = JSON.stringify(value);
+            }
+            yield jsonStr + '\n';
+        }
     }
-
-    /**
-     * Обработка сообщений от 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);
-      }
+    async function* csvToJsonChunkIterator(input, options = {}) {
+        if (typeof input === 'string') {
+            // Используем csvToJsonIterator из csv-to-json-browser
+            yield* csvToJsonIterator$1(input, options);
+        }
+        else if (input instanceof File || input instanceof Blob) {
+            const text = await input.text();
+            yield* csvToJsonIterator$1(text, options);
+        }
+        else if (isReadableStream(input)) {
+            const reader = input.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    // Обработка буфера по строкам
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    // TODO: Реализовать парсинг CSV из чанков
+                    // Пока просто возвращаем сырые строки
+                    for (const line of lines) {
+                        if (line.trim()) {
+                            yield { raw: line };
+                        }
+                    }
+                }
+                // Обработка остатка буфера
+                if (buffer.trim()) {
+                    yield { raw: buffer };
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        else {
+            throw new ValidationError('Unsupported input type for CSV streaming');
+        }
     }
-
-    /**
-     * Обработка прогресса задачи
-     * @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
-          });
-        }
-      }
+    function jsonToCsvStream$1(input, options = {}) {
+        const iterator = jsonToCsvChunkIterator(input, options);
+        return createReadableStreamFromIterator(iterator);
     }
-
-    /**
-     * Обработка результата задачи
-     * @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();
-      }
+    function jsonToNdjsonStream$1(input, options = {}) {
+        const iterator = jsonToNdjsonChunkIterator(input, options);
+        return createReadableStreamFromIterator(iterator);
     }
-
-    /**
-     * Обработка ошибки задачи
-     * @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();
-      }
+    function csvToJsonStream$1(input, options = {}) {
+        const iterator = csvToJsonChunkIterator(input, options);
+        return createReadableStreamFromIterator(iterator);
     }
-
-    /**
-     * Обработка ошибок worker
-     * @private
+    /**
+     * Асинхронная версия jsonToCsvStream
      */
-    handleWorkerError(worker, error) {
-      console.error(`Worker ${worker.id} error:`, error);
-
-      // Перезапуск worker
-      this.restartWorker(worker);
+    async function jsonToCsvStreamAsync(input, options = {}) {
+        return jsonToCsvStream$1(input, options);
     }
-
-    /**
-     * Обработка ошибок сообщений
-     * @private
+    /**
+     * Асинхронная версия jsonToNdjsonStream
      */
-    handleWorkerMessageError(worker, error) {
-      console.error(`Worker ${worker.id} message error:`, error);
+    async function jsonToNdjsonStreamAsync(input, options = {}) {
+        return jsonToNdjsonStream$1(input, options);
+    }
+    /**
+     * Асинхронная версия csvToJsonStream
+     */
+    async function csvToJsonStreamAsync(input, options = {}) {
+        return csvToJsonStream$1(input, options);
+    }
+    // Экспорт для Node.js совместимости
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = {
+            jsonToCsvStream: jsonToCsvStream$1,
+            jsonToCsvStreamAsync,
+            jsonToNdjsonStream: jsonToNdjsonStream$1,
+            jsonToNdjsonStreamAsync,
+            csvToJsonStream: csvToJsonStream$1,
+            csvToJsonStreamAsync,
+            createReadableStreamFromIterator
+        };
     }
 
-    /**
-     * Перезапуск 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--;
+    // Браузерные специфичные функции для jtcsv
+    // Функции, которые работают только в браузере
+    /**
+     * Скачивает JSON данные как CSV файл
+     *
+     * @param data - Массив объектов для конвертации
+     * @param filename - Имя файла для скачивания (по умолчанию 'data.csv')
+     * @param options - Опции для jsonToCsv
+     *
+     * @example
+     * const data = [
+     *   { id: 1, name: 'John' },
+     *   { id: 2, name: 'Jane' }
+     * ];
+     * downloadAsCsv(data, 'users.csv', { delimiter: ',' });
+     */
+    function downloadAsCsv(data, filename = 'data.csv', options = {}) {
+        // Проверка что мы в браузере
+        if (typeof window === 'undefined') {
+            throw new ValidationError('downloadAsCsv() работает только в браузере. Используйте saveAsCsv() в Node.js');
         }
-        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);
+        // Валидация имени файла
+        if (typeof filename !== 'string' || filename.trim() === '') {
+            throw new ValidationError('Filename must be a non-empty string');
+        }
+        // Добавление расширения .csv если его нет
+        if (!filename.toLowerCase().endsWith('.csv')) {
+            filename += '.csv';
         }
-      }
+        // Конвертация в CSV
+        const csv = jsonToCsv$1(data, options);
+        // Создание Blob
+        const blob = new Blob([csv], {
+            type: 'text/csv;charset=utf-8;'
+        });
+        // Создание ссылки для скачивания
+        const link = document.createElement('a');
+        const url = URL.createObjectURL(blob);
+        link.setAttribute('href', url);
+        link.setAttribute('download', filename);
+        link.style.visibility = 'hidden';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        // Освобождение URL
+        setTimeout(() => URL.revokeObjectURL(url), 100);
+    }
+    /**
+     * Асинхронная версия downloadAsCsv
+     */
+    async function downloadAsCsvAsync$1(data, filename = 'data.csv', options = {}) {
+        return downloadAsCsv(data, filename, options);
+    }
+    /**
+     * Парсит CSV файл из input[type="file"]
+     *
+     * @param file - File объект из input
+     * @param options - Опции для csvToJson
+     * @returns Promise с распарсенными данными
+     */
+    async function parseCsvFile(file, options = {}) {
+        if (!(file instanceof File)) {
+            throw new ValidationError('parseCsvFile() ожидает объект File');
+        }
+        // Чтение файла как текст
+        const text = await file.text();
+        // Парсинг CSV
+        return csvToJson$1(text, options);
+    }
+    /**
+     * Парсит CSV файл потоково
+     *
+     * @param file - File объект
+     * @param options - Опции для потокового парсинга
+     * @returns AsyncIterator с данными
+     */
+    function parseCsvFileStream(file, options = {}) {
+        if (!(file instanceof File)) {
+            throw new ValidationError('parseCsvFileStream() ожидает объект File');
+        }
+        // Используем csvToJsonIterator из импортированного модуля
+        return csvToJsonIterator$1(file, options);
+    }
+    /**
+     * Создает поток для конвертации JSON в CSV
+     *
+     * @param options - Опции для jsonToCsv
+     * @returns ReadableStream
+     */
+    function jsonToCsvStream(options = {}) {
+        return jsonToCsvStream$1(options);
+    }
+    /**
+     * Создает поток для конвертации JSON в NDJSON
+     *
+     * @param options - Опции для конвертации
+     * @returns ReadableStream
+     */
+    function jsonToNdjsonStream(options = {}) {
+        return jsonToNdjsonStream$1(options);
+    }
+    /**
+     * Создает поток для парсинга CSV в JSON
+     *
+     * @param options - Опции для csvToJson
+     * @returns ReadableStream
+     */
+    function csvToJsonStream(options = {}) {
+        return csvToJsonStream$1(options);
+    }
+    /**
+     * Загружает CSV файл по URL
+     *
+     * @param url - URL CSV файла
+     * @param options - Опции для csvToJson
+     * @returns Promise с распарсенными данными
+     */
+    async function loadCsvFromUrl(url, options = {}) {
+        if (typeof window === 'undefined') {
+            throw new ValidationError('loadCsvFromUrl() работает только в браузере');
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new ValidationError(`Failed to load CSV from URL: ${response.status} ${response.statusText}`);
+        }
+        const text = await response.text();
+        return csvToJson$1(text, options);
     }
-
-    /**
-     * Выполнение задачи на 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);
-      }
+    /**
+     * Асинхронная версия 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;
+        }
     }
-
-    /**
-     * Обработка очереди задач
-     * @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();
+    /**
+     * Сохраняет 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);
     }
-
-    /**
-     * Обновление статистики
-     * @private
+    /**
+     * Асинхронная версия loadCsvFromLocalStorage
      */
-    updateStats() {
-      this.stats.queueSize = this.taskQueue.length;
+    async function loadCsvFromLocalStorageAsync(key, options = {}) {
+        return loadCsvFromLocalStorage(key, options);
+    }
+    /**
+     * Создает CSV файл из JSON данных (альтернатива downloadAsCsv)
+     * Возвращает Blob вместо автоматического скачивания
+     *
+     * @param data - Массив объектов
+     * @param options - Опции для jsonToCsv
+     * @returns CSV Blob
+     */
+    function createCsvBlob(data, options = {}) {
+        const csv = jsonToCsv$1(data, options);
+        return new Blob([csv], {
+            type: 'text/csv;charset=utf-8;'
+        });
     }
-
-    /**
-     * Выполнение задачи через 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;
+    /**
+     * Асинхронная версия createCsvBlob
+     */
+    async function createCsvBlobAsync(data, options = {}) {
+        return createCsvBlob(data, options);
+    }
+    /**
+     * Парсит CSV строку из Blob
+     *
+     * @param blob - CSV Blob
+     * @param options - Опции для csvToJson
+     * @returns Promise с JSON данными
+     */
+    async function parseCsvBlob(blob, options = {}) {
+        if (!(blob instanceof Blob)) {
+            throw new ValidationError('Input must be a Blob object');
         }
-
-        // Создание задачи
-        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();
-      });
+        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');
+        });
     }
-
-    /**
-     * Получение статистики pool
-     * @returns {WorkerPoolStats} Статистика
+    /**
+     * Асинхронная версия parseCsvBlob
      */
-    getStats() {
-      return {
-        ...this.stats
-      };
+    async function parseCsvBlobAsync(blob, options = {}) {
+        return parseCsvBlob(blob, options);
+    }
+    // Экспорт для Node.js совместимости
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = {
+            downloadAsCsv,
+            downloadAsCsvAsync: downloadAsCsvAsync$1,
+            parseCsvFile,
+            parseCsvFileStream,
+            createCsvBlob,
+            createCsvBlobAsync,
+            parseCsvBlob,
+            parseCsvBlobAsync,
+            jsonToCsvStream,
+            jsonToNdjsonStream,
+            csvToJsonStream,
+            loadCsvFromUrl,
+            loadCsvFromUrlAsync,
+            openCsvInNewTab,
+            openCsvInNewTabAsync,
+            copyCsvToClipboard,
+            saveCsvToLocalStorage,
+            loadCsvFromLocalStorage,
+            loadCsvFromLocalStorageAsync
+        };
     }
 
-    /**
-     * Очистка простаивающих 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--;
+    // Worker Pool для параллельной обработки CSV
+    // Использует Comlink для простой коммуникации с Web Workers
+    // Проверка поддержки Web Workers
+    const WORKERS_SUPPORTED = typeof Worker !== 'undefined';
+    function isTransferableBuffer(value) {
+        if (!(value instanceof ArrayBuffer)) {
+            return false;
+        }
+        if (typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer) {
+            return false;
+        }
+        return true;
+    }
+    function collectTransferables(args) {
+        const transferables = [];
+        const collectFromValue = (value) => {
+            if (!value) {
+                return;
+            }
+            if (isTransferableBuffer(value)) {
+                transferables.push(value);
+                return;
+            }
+            if (ArrayBuffer.isView(value) && isTransferableBuffer(value.buffer)) {
+                transferables.push(value.buffer);
+                return;
+            }
+            if (Array.isArray(value)) {
+                value.forEach(collectFromValue);
+            }
+        };
+        args.forEach(collectFromValue);
+        return transferables.length ? transferables : null;
+    }
+    /**
+     * Опции для Worker Pool
+     * @typedef {Object} WorkerPoolOptions
+     * @property {number} [workerCount=4] - Количество workers в pool
+     * @property {number} [maxQueueSize=100] - Максимальный размер очереди задач
+     * @property {boolean} [autoScale=true] - Автоматическое масштабирование pool
+     * @property {number} [idleTimeout=60000] - Таймаут простоя worker (мс)
+     */
+    /**
+     * Статистика Worker Pool
+     * @typedef {Object} WorkerPoolStats
+     * @property {number} totalWorkers - Всего workers
+     * @property {number} activeWorkers - Активные workers
+     * @property {number} idleWorkers - Простаивающие workers
+     * @property {number} queueSize - Размер очереди
+     * @property {number} tasksCompleted - Завершенные задачи
+     * @property {number} tasksFailed - Неудачные задачи
+     */
+    /**
+     * Прогресс обработки задачи
+     * @typedef {Object} TaskProgress
+     * @property {number} processed - Обработано элементов
+     * @property {number} total - Всего элементов
+     * @property {number} percentage - Процент выполнения
+     * @property {number} speed - Скорость обработки (элементов/сек)
+     */
+    /**
+     * Worker Pool для параллельной обработки CSV
+     */
+    class WorkerPool {
+        /**
+         * Создает новый Worker Pool
+         * @param {string} workerScript - URL скрипта worker
+         * @param {WorkerPoolOptions} [options] - Опции pool
+         */
+        constructor(workerScript, options = {}) {
+            if (!WORKERS_SUPPORTED) {
+                throw new ValidationError('Web Workers не поддерживаются в этом браузере');
+            }
+            this.workerScript = workerScript;
+            this.options = {
+                workerCount: 4,
+                maxQueueSize: 100,
+                autoScale: true,
+                idleTimeout: 60000,
+                ...options
+            };
+            this.workers = [];
+            this.taskQueue = [];
+            this.activeTasks = new Map();
+            this.stats = {
+                totalWorkers: 0,
+                activeWorkers: 0,
+                idleWorkers: 0,
+                queueSize: 0,
+                tasksCompleted: 0,
+                tasksFailed: 0
+            };
+            this.initializeWorkers();
+        }
+        /**
+         * Инициализация workers
+         * @private
+         */
+        initializeWorkers() {
+            const { workerCount } = this.options;
+            for (let i = 0; i < workerCount; i++) {
+                this.createWorker();
+            }
+            this.updateStats();
+        }
+        /**
+         * Создает нового worker
+         * @private
+         */
+        createWorker() {
+            try {
+                const worker = new Worker(this.workerScript, { type: 'module' });
+                worker.id = `worker-${this.workers.length}`;
+                worker.status = 'idle';
+                worker.lastUsed = Date.now();
+                worker.taskId = null;
+                // Обработчики событий
+                worker.onmessage = (event) => this.handleWorkerMessage(worker, event);
+                worker.onerror = (error) => this.handleWorkerError(worker, error);
+                worker.onmessageerror = (error) => this.handleWorkerMessageError(worker, error);
+                this.workers.push(worker);
+                this.stats.totalWorkers++;
+                this.stats.idleWorkers++;
+                return worker;
+            }
+            catch (error) {
+                throw new ConfigurationError(`Не удалось создать worker: ${error.message}`);
+            }
+        }
+        /**
+         * Обработка сообщений от worker
+         * @private
+         */
+        handleWorkerMessage(worker, event) {
+            const { data } = event;
+            if (data.type === 'PROGRESS') {
+                this.handleProgress(worker, data);
+            }
+            else if (data.type === 'RESULT') {
+                this.handleResult(worker, data);
+            }
+            else if (data.type === 'ERROR') {
+                this.handleWorkerTaskError(worker, data);
+            }
+        }
+        /**
+         * Обработка прогресса задачи
+         * @private
+         */
+        handleProgress(worker, progressData) {
+            const taskId = worker.taskId;
+            if (taskId && this.activeTasks.has(taskId)) {
+                const task = this.activeTasks.get(taskId);
+                if (task.onProgress) {
+                    task.onProgress({
+                        processed: progressData.processed,
+                        total: progressData.total,
+                        percentage: (progressData.processed / progressData.total) * 100,
+                        speed: progressData.speed || 0
+                    });
+                }
+            }
+        }
+        /**
+         * Обработка результата задачи
+         * @private
+         */
+        handleResult(worker, resultData) {
+            const taskId = worker.taskId;
+            if (taskId && this.activeTasks.has(taskId)) {
+                const task = this.activeTasks.get(taskId);
+                // Освобождение worker
+                worker.status = 'idle';
+                worker.lastUsed = Date.now();
+                worker.taskId = null;
+                this.stats.activeWorkers--;
+                this.stats.idleWorkers++;
+                // Завершение задачи
+                task.resolve(resultData.data);
+                this.activeTasks.delete(taskId);
+                this.stats.tasksCompleted++;
+                // Обработка следующей задачи в очереди
+                this.processQueue();
+                this.updateStats();
+            }
+        }
+        /**
+         * Обработка ошибки задачи
+         * @private
+         */
+        handleWorkerTaskError(worker, errorData) {
+            const taskId = worker.taskId;
+            if (taskId && this.activeTasks.has(taskId)) {
+                const task = this.activeTasks.get(taskId);
+                // Освобождение worker
+                worker.status = 'idle';
+                worker.lastUsed = Date.now();
+                worker.taskId = null;
+                this.stats.activeWorkers--;
+                this.stats.idleWorkers++;
+                // Завершение с ошибкой
+                const workerError = new Error(errorData.message || 'Ошибка в worker');
+                if (errorData.code) {
+                    workerError.code = errorData.code;
+                }
+                if (errorData.details) {
+                    workerError.details = errorData.details;
+                }
+                task.reject(workerError);
+                this.activeTasks.delete(taskId);
+                this.stats.tasksFailed++;
+                // Обработка следующей задачи
+                this.processQueue();
+                this.updateStats();
+            }
+        }
+        /**
+         * Обработка ошибок worker
+         * @private
+         */
+        handleWorkerError(worker, error) {
+            console.error(`Worker ${worker.id} error:`, error);
+            // Перезапуск worker
+            this.restartWorker(worker);
+        }
+        /**
+         * Обработка ошибок сообщений
+         * @private
+         */
+        handleWorkerMessageError(worker, error) {
+            console.error(`Worker ${worker.id} message error:`, error);
+        }
+        /**
+         * Перезапуск worker
+         * @private
+         */
+        restartWorker(worker) {
+            const index = this.workers.indexOf(worker);
+            if (index !== -1) {
+                // Завершение старого worker
+                worker.terminate();
+                // Удаление из статистики
+                if (worker.status === 'active') {
+                    this.stats.activeWorkers--;
+                }
+                else {
+                    this.stats.idleWorkers--;
+                }
+                this.stats.totalWorkers--;
+                // Создание нового worker
+                const newWorker = this.createWorker();
+                this.workers[index] = newWorker;
+                // Перезапуск задачи если была активна
+                if (worker.taskId && this.activeTasks.has(worker.taskId)) {
+                    const task = this.activeTasks.get(worker.taskId);
+                    this.executeTask(newWorker, task);
+                }
+            }
+        }
+        /**
+         * Выполнение задачи на worker
+         * @private
+         */
+        executeTask(worker, task) {
+            worker.status = 'active';
+            worker.lastUsed = Date.now();
+            worker.taskId = task.id;
             this.stats.idleWorkers--;
-          }
+            this.stats.activeWorkers++;
+            // Отправка задачи в worker
+            const payload = {
+                type: 'EXECUTE',
+                taskId: task.id,
+                method: task.method,
+                args: task.args,
+                options: task.options
+            };
+            if (task.transferList && task.transferList.length) {
+                worker.postMessage(payload, task.transferList);
+            }
+            else {
+                worker.postMessage(payload);
+            }
+        }
+        /**
+         * Обработка очереди задач
+         * @private
+         */
+        processQueue() {
+            if (this.taskQueue.length === 0) {
+                return;
+            }
+            while (this.taskQueue.length > 0) {
+                const idleWorker = this.workers.find(w => w.status === 'idle');
+                if (!idleWorker) {
+                    if (this.options.autoScale && this.workers.length < this.options.maxQueueSize) {
+                        this.createWorker();
+                        continue;
+                    }
+                    break;
+                }
+                const task = this.taskQueue.shift();
+                this.stats.queueSize--;
+                this.executeTask(idleWorker, task);
+            }
+            this.updateStats();
+        }
+        /**
+         * Обновление статистики
+         * @private
+         */
+        updateStats() {
+            this.stats.queueSize = this.taskQueue.length;
+        }
+        /**
+         * Выполнение задачи через pool
+         * @param {string} method - Метод для вызова в worker
+         * @param {Array} args - Аргументы метода
+         * @param {Object} [options] - Опции задачи
+         * @param {Function} [onProgress] - Callback прогресса
+         * @returns {Promise<unknown>} Результат выполнения
+         */
+        async exec(method, args = [], options = {}, onProgress = null) {
+            return new Promise((resolve, reject) => {
+                // Проверка размера очереди
+                if (this.taskQueue.length >= this.options.maxQueueSize) {
+                    reject(new Error('Очередь задач переполнена'));
+                    return;
+                }
+                // Создание задачи
+                const taskId = `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+                const { transfer, ...taskOptions } = options || {};
+                const transferList = transfer || collectTransferables(args);
+                const task = {
+                    id: taskId,
+                    method,
+                    args,
+                    options: taskOptions,
+                    transferList,
+                    onProgress,
+                    resolve,
+                    reject,
+                    createdAt: Date.now()
+                };
+                // Добавление в очередь
+                this.taskQueue.push(task);
+                this.stats.queueSize++;
+                // Запуск обработки очереди
+                this.processQueue();
+                this.updateStats();
+            });
+        }
+        /**
+         * Получение статистики pool
+         * @returns {WorkerPoolStats} Статистика
+         */
+        getStats() {
+            return { ...this.stats };
+        }
+        /**
+         * Очистка простаивающих workers
+         */
+        cleanupIdleWorkers() {
+            const now = Date.now();
+            const { idleTimeout } = this.options;
+            for (let i = this.workers.length - 1; i >= 0; i--) {
+                const worker = this.workers[i];
+                if (worker.status === 'idle' && (now - worker.lastUsed) > idleTimeout) {
+                    // Сохранение минимального количества workers
+                    if (this.workers.length > 1) {
+                        worker.terminate();
+                        this.workers.splice(i, 1);
+                        this.stats.totalWorkers--;
+                        this.stats.idleWorkers--;
+                    }
+                }
+            }
+        }
+        /**
+         * Завершение всех workers
+         */
+        terminate() {
+            this.workers.forEach(worker => {
+                worker.terminate();
+            });
+            this.workers = [];
+            this.taskQueue = [];
+            this.activeTasks.clear();
+            // Сброс статистики
+            this.stats = {
+                totalWorkers: 0,
+                activeWorkers: 0,
+                idleWorkers: 0,
+                queueSize: 0,
+                tasksCompleted: 0,
+                tasksFailed: 0
+            };
         }
-      }
     }
-
-    /**
-     * Завершение всех workers
-     */
-    terminate() {
-      this.workers.forEach(worker => {
-        worker.terminate();
-      });
-      this.workers = [];
-      this.taskQueue = [];
-      this.activeTasks.clear();
-
-      // Сброс статистики
-      this.stats = {
-        totalWorkers: 0,
-        activeWorkers: 0,
-        idleWorkers: 0,
-        queueSize: 0,
-        tasksCompleted: 0,
-        tasksFailed: 0
-      };
-    }
-  }
-
-  /**
-   * Создает Worker Pool для обработки CSV
-   * @param {WorkerPoolOptions} [options] - Опции pool
-   * @returns {WorkerPool} Worker Pool
-   */
-  function createWorkerPool(options = {}) {
-    // Используем встроенный worker скрипт
-    const workerScript = new URL('./csv-parser.worker.js', (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('jtcsv.umd.js', document.baseURI).href))).href;
-    return new WorkerPool(workerScript, options);
-  }
-
-  /**
-   * Парсит CSV с использованием Web Workers
-   * @param {string|File} csvInput - CSV строка или File объект
-   * @param {Object} [options] - Опции парсинга
-   * @param {Function} [onProgress] - Callback прогресса
-   * @returns {Promise<Array<Object>>} JSON данные
-   */
-  async function parseCSVWithWorker(csvInput, options = {}, onProgress = null) {
-    // Создание pool если нужно
-    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');
+    /**
+     * Создает Worker Pool для обработки CSV
+     * @param {WorkerPoolOptions} [options] - Опции pool
+     * @returns {WorkerPool} Worker Pool
+     */
+    function createWorkerPool(options = {}) {
+        // Используем встроенный worker скрипт
+        const baseUrl = typeof document !== 'undefined'
+            ? document.baseURI
+            : (typeof self !== 'undefined' && self.location
+                ? self.location.href
+                : '');
+        const workerScript = new URL('./csv-parser.worker.js', baseUrl).href;
+        return new WorkerPool(workerScript, options);
+    }
+    /**
+     * Парсит CSV с использованием Web Workers
+     * @param {string|File} csvInput - CSV строка или File объект
+     * @param {Object} [options] - Опции парсинга
+     * @param {Function} [onProgress] - Callback прогресса
+     * @returns {Promise<Array<Object>>} JSON данные
+     */
+    async function parseCSVWithWorker(csvInput, options = {}, onProgress = null) {
+        // Создание pool если нужно
+        const poolHolder = parseCSVWithWorker;
+        if (!poolHolder.pool) {
+            poolHolder.pool = createWorkerPool();
+        }
+        const pool = poolHolder.pool;
+        // Подготовка CSV строки
+        // ?????????? CSV ??????
+        let csvPayload = csvInput;
+        let transfer = null;
+        if (csvInput instanceof File) {
+            const buffer = await readFileAsArrayBuffer(csvInput);
+            csvPayload = new Uint8Array(buffer);
+            transfer = [buffer];
+        }
+        else if (csvInput instanceof ArrayBuffer) {
+            csvPayload = csvInput;
+            transfer = [csvInput];
+        }
+        else if (ArrayBuffer.isView(csvInput)) {
+            csvPayload = csvInput;
+            if (csvInput.buffer instanceof ArrayBuffer) {
+                transfer = [csvInput.buffer];
+            }
+        }
+        else if (typeof csvInput !== 'string') {
+            throw new ValidationError('Input must be a CSV string, File, or ArrayBuffer');
+        }
+        // ????????? ?????? ????? pool
+        const execOptions = transfer ? { transfer } : {};
+        return pool.exec('parseCSV', [csvPayload, options], execOptions, onProgress);
+    }
+    /**
+     * Чтение файла как текст
+     * @private
+     */
+    async function readFileAsArrayBuffer(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = (event) => resolve(event.target.result);
+            reader.onerror = (error) => reject(error);
+            reader.readAsArrayBuffer(file);
+        });
+    }
+    // Экспорт для Node.js совместимости
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = {
+            WorkerPool,
+            createWorkerPool,
+            parseCSVWithWorker
+        };
     }
 
-    // ????????? ?????? ????? pool
-    const execOptions = transfer ? {
-      transfer
-    } : {};
-    return pool.exec('parseCSV', [csvPayload, options], execOptions, onProgress);
-  }
-
-  /**
-   * Чтение файла как текст
-   * @private
-   */
-  async function readFileAsArrayBuffer(file) {
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = event => resolve(event.target.result);
-      reader.onerror = error => reject(error);
-      reader.readAsArrayBuffer(file);
+    var workerPool = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        WorkerPool: WorkerPool,
+        createWorkerPool: createWorkerPool,
+        parseCSVWithWorker: parseCSVWithWorker
     });
-  }
 
-  // Экспорт для Node.js совместимости
-  if (typeof module !== 'undefined' && module.exports) {
-    module.exports = {
-      WorkerPool,
-      createWorkerPool,
-      parseCSVWithWorker
+    // Браузерный entry point для jtcsv
+    // Экспортирует все функции с поддержкой браузера
+    const { jsonToCsv, preprocessData, deepUnwrap } = jsonToCsvBrowser;
+    const { csvToJson, csvToJsonIterator, autoDetectDelimiter } = csvToJsonBrowser;
+    /**
+     * Ленивая инициализация Worker Pool
+     */
+    async function createWorkerPoolLazy(options = {}) {
+        const mod = await Promise.resolve().then(function () { return workerPool; });
+        return mod.createWorkerPool(options);
+    }
+    /**
+     * Ленивый парсинг CSV с использованием Worker
+     */
+    async function parseCSVWithWorkerLazy(csvInput, options = {}, onProgress) {
+        const mod = await Promise.resolve().then(function () { return workerPool; });
+        return mod.parseCSVWithWorker(csvInput, options, onProgress);
+    }
+    /**
+     * Асинхронная версия jsonToCsv
+     */
+    async function jsonToCsvAsync(data, options = {}) {
+        return jsonToCsv(data, options);
+    }
+    /**
+     * Асинхронная версия csvToJson
+     */
+    async function csvToJsonAsync(csv, options = {}) {
+        return csvToJson(csv, options);
+    }
+    /**
+     * Асинхронная версия parseCsvFile
+     */
+    async function parseCsvFileAsync(file, options = {}) {
+        return parseCsvFile(file, options);
+    }
+    /**
+     * Асинхронная версия autoDetectDelimiter
+     */
+    async function autoDetectDelimiterAsync(csv) {
+        return autoDetectDelimiter(csv);
+    }
+    /**
+     * Асинхронная версия downloadAsCsv
+     */
+    async function downloadAsCsvAsync(data, filename = 'export.csv', options = {}) {
+        return downloadAsCsv(data, filename, options);
+    }
+    // Основной экспорт
+    const jtcsv = {
+        // JSON to CSV функции
+        jsonToCsv,
+        preprocessData,
+        downloadAsCsv,
+        deepUnwrap,
+        // CSV to JSON функции
+        csvToJson,
+        csvToJsonIterator,
+        parseCsvFile,
+        parseCsvFileStream,
+        jsonToCsvStream,
+        jsonToNdjsonStream,
+        csvToJsonStream,
+        autoDetectDelimiter,
+        // Web Workers функции
+        createWorkerPool,
+        parseCSVWithWorker,
+        createWorkerPoolLazy,
+        parseCSVWithWorkerLazy,
+        // Асинхронные функции
+        jsonToCsvAsync,
+        csvToJsonAsync,
+        parseCsvFileAsync,
+        autoDetectDelimiterAsync,
+        downloadAsCsvAsync,
+        // Error classes
+        ValidationError,
+        SecurityError,
+        FileSystemError,
+        ParsingError,
+        LimitError,
+        ConfigurationError,
+        ERROR_CODES,
+        // Удобные алиасы
+        parse: csvToJson,
+        unparse: jsonToCsv,
+        parseAsync: csvToJsonAsync,
+        unparseAsync: jsonToCsvAsync,
+        // Версия
+        version: '2.0.0-browser'
     };
-  }
-
-  var workerPool = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    WorkerPool: WorkerPool,
-    createWorkerPool: createWorkerPool,
-    parseCSVWithWorker: parseCSVWithWorker
-  });
-
-  // Браузерный entry point для jtcsv
-  // Экспортирует все функции с поддержкой браузера
-
-  async function createWorkerPoolLazy(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);
-  }
-
-  // Основной экспорт
-  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'
-  };
-
-  // Экспорт для разных сред
-  if (typeof module !== 'undefined' && module.exports) {
-    // Node.js CommonJS
-    module.exports = jtcsv;
-  } else if (typeof define === 'function' && define.amd) {
-    // AMD
-    define([], () => jtcsv);
-  } else if (typeof window !== 'undefined') {
-    // Браузер (глобальная переменная)
-    window.jtcsv = jtcsv;
-  }
-
-  exports.ConfigurationError = ConfigurationError;
-  exports.ERROR_CODES = ERROR_CODES;
-  exports.FileSystemError = FileSystemError;
-  exports.LimitError = LimitError;
-  exports.ParsingError = ParsingError;
-  exports.SecurityError = SecurityError;
-  exports.ValidationError = ValidationError;
-  exports.autoDetectDelimiter = autoDetectDelimiter;
-  exports.createWorkerPool = createWorkerPool;
-  exports.createWorkerPoolLazy = createWorkerPoolLazy;
-  exports.csvToJson = csvToJson;
-  exports.csvToJsonIterator = csvToJsonIterator;
-  exports.csvToJsonStream = csvToJsonStream;
-  exports.deepUnwrap = deepUnwrap;
-  exports.default = jtcsv;
-  exports.downloadAsCsv = downloadAsCsv;
-  exports.jsonToCsv = jsonToCsv;
-  exports.jsonToCsvStream = jsonToCsvStream;
-  exports.jsonToNdjsonStream = jsonToNdjsonStream;
-  exports.parseCSVWithWorker = parseCSVWithWorker;
-  exports.parseCSVWithWorkerLazy = parseCSVWithWorkerLazy;
-  exports.parseCsvFile = parseCsvFile;
-  exports.parseCsvFileStream = parseCsvFileStream;
-  exports.preprocessData = preprocessData;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
+    // Экспорт для разных сред
+    if (typeof module !== 'undefined' && module.exports) {
+        // Node.js CommonJS
+        module.exports = jtcsv;
+    }
+    else if (typeof define === 'function' && define.amd) {
+        // AMD
+        define([], () => jtcsv);
+    }
+    else if (typeof window !== 'undefined') {
+        // Браузер (глобальная переменная)
+        window.jtcsv = jtcsv;
+    }
+
+    exports.ConfigurationError = ConfigurationError;
+    exports.ERROR_CODES = ERROR_CODES;
+    exports.FileSystemError = FileSystemError;
+    exports.LimitError = LimitError;
+    exports.ParsingError = ParsingError;
+    exports.SecurityError = SecurityError;
+    exports.ValidationError = ValidationError;
+    exports.autoDetectDelimiter = autoDetectDelimiter;
+    exports.autoDetectDelimiterAsync = autoDetectDelimiterAsync;
+    exports.createWorkerPool = createWorkerPool;
+    exports.createWorkerPoolLazy = createWorkerPoolLazy;
+    exports.csvToJson = csvToJson;
+    exports.csvToJsonAsync = csvToJsonAsync;
+    exports.csvToJsonIterator = csvToJsonIterator;
+    exports.csvToJsonStream = csvToJsonStream;
+    exports.deepUnwrap = deepUnwrap;
+    exports.default = jtcsv;
+    exports.downloadAsCsv = downloadAsCsv;
+    exports.downloadAsCsvAsync = downloadAsCsvAsync;
+    exports.jsonToCsv = jsonToCsv;
+    exports.jsonToCsvAsync = jsonToCsvAsync;
+    exports.jsonToCsvStream = jsonToCsvStream;
+    exports.jsonToNdjsonStream = jsonToNdjsonStream;
+    exports.parseCSVWithWorker = parseCSVWithWorker;
+    exports.parseCSVWithWorkerLazy = parseCSVWithWorkerLazy;
+    exports.parseCsvFile = parseCsvFile;
+    exports.parseCsvFileAsync = parseCsvFileAsync;
+    exports.parseCsvFileStream = parseCsvFileStream;
+    exports.preprocessData = preprocessData;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
 //# sourceMappingURL=jtcsv.umd.js.map