jtcsv 1.2.0 → 2.1.0

package/dist/jtcsv.cjs.js

@@ -0,0 +1,1619 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// Система ошибок для браузерной версии jtcsv
+// Адаптирована для работы без Node.js специфичных API
+
+/**
+ * Базовый класс ошибки jtcsv
+ */
+class JTCSVError extends Error {
+  constructor(message, code = 'JTCSV_ERROR', details = {}) {
+    super(message);
+    this.name = 'JTCSVError';
+    this.code = code;
+    this.details = details;
+
+    // Сохранение stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, JTCSVError);
+    }
+  }
+}
+
+/**
+ * Ошибка валидации
+ */
+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';
+  }
+}
+
+/**
+ * Безопасное выполнение функции с обработкой ошибок
+ * 
+ * @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,
+    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');
+  }
+
+  // Validate delimiter
+  if (options !== null && options !== void 0 && options.delimiter && typeof options.delimiter !== 'string') {
+    throw new ConfigurationError('Delimiter must be a string');
+  }
+  if (options !== null && options !== void 0 && options.delimiter && options.delimiter.length !== 1) {
+    throw new ConfigurationError('Delimiter must be a single character');
+  }
+
+  // Validate renameMap
+  if (options !== null && options !== void 0 && options.renameMap && typeof options.renameMap !== 'object') {
+    throw new ConfigurationError('renameMap must be an object');
+  }
+
+  // Validate maxRecords
+  if (options && options.maxRecords !== undefined) {
+    if (typeof options.maxRecords !== 'number' || options.maxRecords <= 0) {
+      throw new ConfigurationError('maxRecords must be a positive number');
+    }
+  }
+
+  // Validate preventCsvInjection
+  if ((options === null || options === void 0 ? void 0 : options.preventCsvInjection) !== undefined && typeof options.preventCsvInjection !== 'boolean') {
+    throw new ConfigurationError('preventCsvInjection must be a boolean');
+  }
+
+  // Validate rfc4180Compliant
+  if ((options === null || options === void 0 ? void 0 : options.rfc4180Compliant) !== undefined && typeof options.rfc4180Compliant !== 'boolean') {
+    throw new ConfigurationError('rfc4180Compliant must be a boolean');
+  }
+  return true;
+}
+
+/**
+ * Конвертирует JSON данные в CSV формат
+ * 
+ * @param {Array<Object>} data - Массив объектов для конвертации в CSV
+ * @param {Object} [options] - Опции конфигурации
+ * @param {string} [options.delimiter=';'] - CSV разделитель
+ * @param {boolean} [options.includeHeaders=true] - Включать ли заголовки
+ * @param {Object} [options.renameMap={}] - Маппинг переименования заголовков
+ * @param {Object} [options.template={}] - Шаблон для порядка колонок
+ * @param {number} [options.maxRecords] - Максимальное количество записей
+ * @param {boolean} [options.preventCsvInjection=true] - Защита от CSV инъекций
+ * @param {boolean} [options.rfc4180Compliant=true] - Соответствие RFC 4180
+ * @returns {string} CSV строка
+ */
+function jsonToCsv(data, options = {}) {
+  return safeExecute(() => {
+    // Валидация входных данных
+    validateInput(data, options);
+    const opts = options && typeof options === 'object' ? options : {};
+    const {
+      delimiter = ';',
+      includeHeaders = true,
+      renameMap = {},
+      template = {},
+      maxRecords,
+      preventCsvInjection = true,
+      rfc4180Compliant = true
+    } = opts;
+
+    // Обработка пустых данных
+    if (data.length === 0) {
+      return '';
+    }
+
+    // Предупреждение для больших наборов данных
+    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;
+      }
+
+      // Соответствие RFC 4180
+      const needsQuoting = rfc4180Compliant ? escapedValue.includes(delimiter) || escapedValue.includes('"') || escapedValue.includes('\n') || escapedValue.includes('\r') : escapedValue.includes(delimiter) || escapedValue.includes('"') || escapedValue.includes('\n') || escapedValue.includes('\r');
+      if (needsQuoting) {
+        return `"${escapedValue.replace(/"/g, '""')}"`;
+      }
+      return escapedValue;
+    };
+
+    // Построение CSV строк
+    const rows = [];
+
+    // Добавление заголовков
+    if (includeHeaders && finalHeaders.length > 0) {
+      rows.push(finalHeaders.join(delimiter));
+    }
+
+    // Добавление данных
+    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);
+  }
+
+  // Обработка массивов
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return '';
+    }
+    const unwrappedItems = value.map(item => deepUnwrap(item, depth + 1, maxDepth, visited)).filter(item => item !== '');
+    return unwrappedItems.join(', ');
+  }
+
+  // Обработка объектов
+  if (typeof value === 'object') {
+    const keys = Object.keys(value);
+    if (keys.length === 0) {
+      return '';
+    }
+    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]';
+      }
+      return '[Unstringifiable Object]';
+    }
+  }
+
+  // Примитивные значения
+  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
+
+
+/**
+ * Валидация CSV ввода и опций
+ * @private
+ */
+function validateCsvInput(csv, options) {
+  // Validate CSV input
+  if (typeof csv !== 'string') {
+    throw new ValidationError('Input must be a CSV string');
+  }
+
+  // Validate options
+  if (options && typeof options !== 'object') {
+    throw new ConfigurationError('Options must be an object');
+  }
+
+  // Validate delimiter
+  if (options !== null && options !== void 0 && options.delimiter && typeof options.delimiter !== 'string') {
+    throw new ConfigurationError('Delimiter must be a string');
+  }
+  if (options !== null && options !== void 0 && options.delimiter && options.delimiter.length !== 1) {
+    throw new ConfigurationError('Delimiter must be a single character');
+  }
+
+  // Validate autoDetect
+  if ((options === null || options === void 0 ? void 0 : options.autoDetect) !== undefined && typeof options.autoDetect !== 'boolean') {
+    throw new ConfigurationError('autoDetect must be a boolean');
+  }
+
+  // Validate candidates
+  if (options !== null && options !== void 0 && options.candidates && !Array.isArray(options.candidates)) {
+    throw new ConfigurationError('candidates must be an array');
+  }
+
+  // Validate maxRows
+  if ((options === null || options === void 0 ? void 0 : options.maxRows) !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
+    throw new ConfigurationError('maxRows must be a positive number');
+  }
+  return true;
+}
+
+/**
+ * Парсинг одной строки 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;
+  }
+
+  // Обработка незавершенного экранирования
+  if (escapeNext) {
+    currentField += '\\';
+  }
+
+  // Добавление последнего поля
+  fields.push(currentField);
+
+  // Проверка незакрытых кавычек
+  if (insideQuotes) {
+    throw new ParsingError('Unclosed quotes in CSV', lineNumber);
+  }
+
+  // Валидация количества полей
+  if (fields.length === 0) {
+    throw new ParsingError('No fields found', lineNumber);
+  }
+  return fields;
+}
+
+/**
+ * Парсинг значения на основе опций
+ * @private
+ */
+function parseCsvValue(value, options) {
+  const {
+    trim = true,
+    parseNumbers = false,
+    parseBooleans = false
+  } = options;
+  let result = value;
+  if (trim) {
+    result = result.trim();
+  }
+
+  // Удаление защиты формул Excel
+  if (result.startsWith("'")) {
+    result = result.substring(1);
+  }
+
+  // Парсинг чисел
+  if (parseNumbers && /^-?\d+(\.\d+)?$/.test(result)) {
+    const num = parseFloat(result);
+    if (!isNaN(num)) {
+      return num;
+    }
+  }
+
+  // Парсинг булевых значений
+  if (parseBooleans) {
+    const lowerValue = result.toLowerCase();
+    if (lowerValue === 'true') {
+      return true;
+    }
+    if (lowerValue === 'false') {
+      return false;
+    }
+  }
+
+  // Пустые строки как null
+  if (result === '') {
+    return null;
+  }
+  return result;
+}
+
+/**
+ * Автоматическое определение разделителя CSV
+ * 
+ * @param {string} csv - CSV строка
+ * @param {Array} [candidates=[';', ',', '\t', '|']] - Кандидаты на разделитель
+ * @returns {string} Определенный разделитель
+ */
+function autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|']) {
+  if (!csv || typeof csv !== 'string') {
+    return ';'; // значение по умолчанию
+  }
+  const lines = csv.split('\n').filter(line => line.trim().length > 0);
+  if (lines.length === 0) {
+    return ';'; // значение по умолчанию
+  }
+
+  // Использование первой непустой строки для определения
+  const firstLine = lines[0];
+  const counts = {};
+  candidates.forEach(delim => {
+    const escapedDelim = delim.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(escapedDelim, 'g');
+    const matches = firstLine.match(regex);
+    counts[delim] = matches ? matches.length : 0;
+  });
+
+  // Поиск разделителя с максимальным количеством
+  let maxCount = -1;
+  let detectedDelimiter = ';'; // значение по умолчанию
+
+  for (const [delim, count] of Object.entries(counts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      detectedDelimiter = delim;
+    }
+  }
+
+  // Если разделитель не найден или ничья
+  if (maxCount === 0) {
+    return ';'; // значение по умолчанию
+  }
+  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
+    } = opts;
+
+    // Определение разделителя
+    let finalDelimiter = delimiter;
+    if (!finalDelimiter && autoDetect) {
+      finalDelimiter = autoDetectDelimiter(csv, candidates);
+    }
+    finalDelimiter = finalDelimiter || ';'; // fallback
+
+    // Обработка пустого CSV
+    if (csv.trim() === '') {
+      return [];
+    }
+
+    // Парсинг 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;
+      }
+      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
+          });
+        }
+
+        // Предупреждение о лишних полях
+        if (fields.length > headers.length && process.env.NODE_ENV === 'development') {
+          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'
+  });
+}
+
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    csvToJson,
+    autoDetectDelimiter
+  };
+}
+
+// Браузерные специфичные функции для 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');
+  }
+
+  // Добавление расширения .csv если его нет
+  if (!filename.toLowerCase().endsWith('.csv')) {
+    filename += '.csv';
+  }
+
+  // Конвертация в CSV
+  const csv = jsonToCsv(data, options);
+
+  // Создание Blob
+  const blob = new Blob([csv], {
+    type: 'text/csv;charset=utf-8;'
+  });
+
+  // Создание ссылки для скачивания
+  const link = document.createElement('a');
+
+  // Создание URL для Blob
+  const url = URL.createObjectURL(blob);
+
+  // Настройка ссылки
+  link.setAttribute('href', url);
+  link.setAttribute('download', filename);
+  link.style.visibility = 'hidden';
+
+  // Добавление в DOM и клик
+  document.body.appendChild(link);
+  link.click();
+
+  // Очистка
+  setTimeout(() => {
+    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');
+  }
+
+  // Валидация файла
+  if (!(file instanceof File)) {
+    throw new ValidationError('Input must be a File object');
+  }
+
+  // Проверка расширения файла
+  if (!file.name.toLowerCase().endsWith('.csv')) {
+    throw new ValidationError('File must have .csv extension');
+  }
+
+  // Проверка размера файла (предупреждение для больших файлов)
+  const MAX_SIZE_WARNING = 50 * 1024 * 1024; // 50MB
+  if (file.size > MAX_SIZE_WARNING && process.env.NODE_ENV !== 'production') {
+    console.warn(`⚠️ Warning: Processing large file (${(file.size / 1024 / 1024).toFixed(2)}MB).\n` + '💡 Consider using Web Workers for better performance.\n' + '🔧 Tip: Use parseCSVWithWorker() for files > 10MB.');
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = function (event) {
+      try {
+        const csvText = event.target.result;
+        const json = csvToJson(csvText, options);
+        resolve(json);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    reader.onerror = function () {
+      reject(new ValidationError('Ошибка чтения файла'));
+    };
+    reader.onabort = function () {
+      reject(new ValidationError('Чтение файла прервано'));
+    };
+
+    // Чтение как текст
+    reader.readAsText(file, 'UTF-8');
+  });
+}
+
+/**
+ * Создает 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,
+    createCsvBlob,
+    parseCsvBlob
+  };
+}
+
+// Worker Pool для параллельной обработки CSV
+// Использует Comlink для простой коммуникации с Web Workers
+
+
+// Проверка поддержки Web Workers
+const WORKERS_SUPPORTED = typeof Worker !== 'undefined';
+
+/**
+ * Опции для 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++;
+
+      // Завершение с ошибкой
+      task.reject(new Error(errorData.message || 'Ошибка в worker'));
+      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
+    worker.postMessage({
+      type: 'EXECUTE',
+      taskId: task.id,
+      method: task.method,
+      args: task.args,
+      options: task.options
+    });
+  }
+
+  /**
+   * Обработка очереди задач
+   * @private
+   */
+  processQueue() {
+    if (this.taskQueue.length === 0) {
+      return;
+    }
+
+    // Поиск свободного worker
+    const idleWorker = this.workers.find(w => w.status === 'idle');
+    if (!idleWorker) {
+      // Автомасштабирование если включено
+      if (this.options.autoScale && this.workers.length < this.options.maxQueueSize) {
+        this.createWorker();
+        this.processQueue();
+      }
+      return;
+    }
+
+    // Получение задачи из очереди
+    const task = this.taskQueue.shift();
+    this.stats.queueSize--;
+
+    // Выполнение задачи
+    this.executeTask(idleWorker, task);
+    this.updateStats();
+  }
+
+  /**
+   * Обновление статистики
+   * @private
+   */
+  updateStats() {
+    this.stats.queueSize = this.taskQueue.length;
+  }
+
+  /**
+   * Выполнение задачи через pool
+   * @param {string} method - Метод для вызова в worker
+   * @param {Array} args - Аргументы метода
+   * @param {Object} [options] - Опции задачи
+   * @param {Function} [onProgress] - Callback прогресса
+   * @returns {Promise<any>} Результат выполнения
+   */
+  async exec(method, args = [], options = {}, onProgress = null) {
+    return new Promise((resolve, reject) => {
+      // Проверка размера очереди
+      if (this.taskQueue.length >= this.options.maxQueueSize) {
+        reject(new Error('Очередь задач переполнена'));
+        return;
+      }
+
+      // Создание задачи
+      const taskId = `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const task = {
+        id: taskId,
+        method,
+        args,
+        options,
+        onProgress,
+        resolve,
+        reject,
+        createdAt: Date.now()
+      };
+
+      // Добавление в очередь
+      this.taskQueue.push(task);
+      this.stats.queueSize++;
+
+      // Запуск обработки очереди
+      this.processQueue();
+      this.updateStats();
+    });
+  }
+
+  /**
+   * Получение статистики pool
+   * @returns {WorkerPoolStats} Статистика
+   */
+  getStats() {
+    return {
+      ...this.stats
+    };
+  }
+
+  /**
+   * Очистка простаивающих workers
+   */
+  cleanupIdleWorkers() {
+    const now = Date.now();
+    const {
+      idleTimeout
+    } = this.options;
+    for (let i = this.workers.length - 1; i >= 0; i--) {
+      const worker = this.workers[i];
+      if (worker.status === 'idle' && now - worker.lastUsed > idleTimeout) {
+        // Сохранение минимального количества workers
+        if (this.workers.length > 1) {
+          worker.terminate();
+          this.workers.splice(i, 1);
+          this.stats.totalWorkers--;
+          this.stats.idleWorkers--;
+        }
+      }
+    }
+  }
+
+  /**
+   * Завершение всех workers
+   */
+  terminate() {
+    this.workers.forEach(worker => {
+      worker.terminate();
+    });
+    this.workers = [];
+    this.taskQueue = [];
+    this.activeTasks.clear();
+
+    // Сброс статистики
+    this.stats = {
+      totalWorkers: 0,
+      activeWorkers: 0,
+      idleWorkers: 0,
+      queueSize: 0,
+      tasksCompleted: 0,
+      tasksFailed: 0
+    };
+  }
+}
+
+/**
+ * Создает Worker Pool для обработки CSV
+ * @param {WorkerPoolOptions} [options] - Опции pool
+ * @returns {WorkerPool} Worker Pool
+ */
+function createWorkerPool(options = {}) {
+  // Используем встроенный worker скрипт
+  const workerScript = new URL('./csv-parser.worker.js', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('jtcsv.cjs.js', document.baseURI).href))).href;
+  return new WorkerPool(workerScript, options);
+}
+
+/**
+ * Парсит 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 строки
+  let csvString;
+  if (csvInput instanceof File) {
+    csvString = await readFileAsText(csvInput);
+  } else if (typeof csvInput === 'string') {
+    csvString = csvInput;
+  } else {
+    throw new ValidationError('Input must be a CSV string or File object');
+  }
+
+  // Выполнение через pool
+  return pool.exec('parseCSV', [csvString, options], {}, onProgress);
+}
+
+/**
+ * Чтение файла как текст
+ * @private
+ */
+async function readFileAsText(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = event => resolve(event.target.result);
+    reader.onerror = error => reject(error);
+    reader.readAsText(file, 'UTF-8');
+  });
+}
+
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    WorkerPool,
+    createWorkerPool,
+    parseCSVWithWorker
+  };
+}
+
+// Браузерный entry point для jtcsv
+// Экспортирует все функции с поддержкой браузера
+
+
+// Основной экспорт
+const jtcsv = {
+  // JSON to CSV функции
+  jsonToCsv,
+  preprocessData,
+  downloadAsCsv,
+  deepUnwrap,
+  // CSV to JSON функции
+  csvToJson,
+  parseCsvFile,
+  autoDetectDelimiter,
+  // Web Workers функции
+  createWorkerPool,
+  parseCSVWithWorker,
+  // Error classes
+  ValidationError,
+  SecurityError,
+  FileSystemError,
+  ParsingError,
+  LimitError,
+  ConfigurationError,
+  // Удобные алиасы
+  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.FileSystemError = FileSystemError;
+exports.LimitError = LimitError;
+exports.ParsingError = ParsingError;
+exports.SecurityError = SecurityError;
+exports.ValidationError = ValidationError;
+exports.autoDetectDelimiter = autoDetectDelimiter;
+exports.createWorkerPool = createWorkerPool;
+exports.csvToJson = csvToJson;
+exports.deepUnwrap = deepUnwrap;
+exports.default = jtcsv;
+exports.downloadAsCsv = downloadAsCsv;
+exports.jsonToCsv = jsonToCsv;
+exports.parseCSVWithWorker = parseCSVWithWorker;
+exports.parseCsvFile = parseCsvFile;
+exports.preprocessData = preprocessData;
+//# sourceMappingURL=jtcsv.cjs.js.map