jtcsv 2.1.3 → 2.2.2

package/dist/jtcsv.umd.js

@@ -100,6 +100,22 @@
       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'
+  };
 
   /**
    * Безопасное выполнение функции с обработкой ошибок
@@ -235,6 +251,7 @@
       ParsingError,
       LimitError,
       ConfigurationError,
+      ERROR_CODES,
       safeExecute,
       safeExecuteAsync
     };
@@ -518,15 +535,10 @@
 
 
   /**
-   * Валидация CSV ввода и опций
+   * Валидация опций парсинга
    * @private
    */
-  function validateCsvInput(csv, options) {
-    // Validate CSV input
-    if (typeof csv !== 'string') {
-      throw new ValidationError('Input must be a CSV string');
-    }
-
+  function validateCsvOptions(options) {
     // Validate options
     if (options && typeof options !== 'object') {
       throw new ConfigurationError('Options must be an object');
@@ -554,9 +566,24 @@
     if (options?.maxRows !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
       throw new ConfigurationError('maxRows must be a positive number');
     }
+    if (options?.warnExtraFields !== undefined && typeof options.warnExtraFields !== 'boolean') {
+      throw new ConfigurationError('warnExtraFields must be a boolean');
+    }
     return true;
   }
 
+  /**
+   * Валидация 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
@@ -702,6 +729,78 @@
     }
     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
@@ -777,7 +876,8 @@
         trim = true,
         parseNumbers = false,
         parseBooleans = false,
-        maxRows
+        maxRows,
+        warnExtraFields = true
       } = opts;
 
       // Определение разделителя
@@ -791,6 +891,16 @@
       if (csv.trim() === '') {
         return [];
       }
+      if (isSimpleCsv(csv)) {
+        return parseSimpleCsv(csv, finalDelimiter, {
+          hasHeaders,
+          renameMap,
+          trim,
+          parseNumbers,
+          parseBooleans,
+          maxRows
+        });
+      }
 
       // Парсинг CSV с обработкой кавычек и переносов строк
       const lines = [];
@@ -894,7 +1004,8 @@
           }
 
           // Предупреждение о лишних полях
-          if (fields.length > headers.length && process.env.NODE_ENV === 'development') {
+          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);
@@ -910,12 +1021,464 @@
       function: 'csvToJson'
     });
   }
+  async function* csvToJsonIterator(input, options = {}) {
+    const opts = options && typeof options === 'object' ? options : {};
+    validateCsvOptions(opts);
+    if (typeof input === 'string') {
+      const rows = csvToJson(input, options);
+      for (const row of rows) {
+        yield row;
+      }
+      return;
+    }
+    const {
+      delimiter,
+      autoDetect = true,
+      candidates = [';', ',', '\t', '|'],
+      hasHeaders = true,
+      renameMap = {},
+      trim = true,
+      parseNumbers = false,
+      parseBooleans = false,
+      maxRows
+    } = opts;
+    const stream = input instanceof Blob && input.stream ? input.stream() : input;
+    if (!stream || typeof stream.getReader !== 'function') {
+      throw new ValidationError('Input must be a CSV string, Blob/File, or ReadableStream');
+    }
+    const reader = stream.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    let insideQuotes = false;
+    let headers = null;
+    let rowCount = 0;
+    let lineNumber = 0;
+    let finalDelimiter = delimiter;
+    let delimiterResolved = Boolean(finalDelimiter);
+    const processFields = fields => {
+      if (fields.length === 1 && fields[0].trim() === '') {
+        return null;
+      }
+      rowCount++;
+      if (maxRows && rowCount > maxRows) {
+        throw new LimitError(`CSV size exceeds maximum limit of ${maxRows} rows`, maxRows, rowCount);
+      }
+      const row = {};
+      const fieldCount = Math.min(fields.length, headers.length);
+      for (let j = 0; j < fieldCount; j++) {
+        row[headers[j]] = parseCsvValue(fields[j], {
+          trim,
+          parseNumbers,
+          parseBooleans
+        });
+      }
+      return row;
+    };
+    const processLine = line => {
+      lineNumber++;
+      let cleanLine = line;
+      if (cleanLine.endsWith('\r')) {
+        cleanLine = cleanLine.slice(0, -1);
+      }
+      if (!delimiterResolved) {
+        if (!finalDelimiter && autoDetect) {
+          finalDelimiter = autoDetectDelimiter(cleanLine, candidates);
+        }
+        finalDelimiter = finalDelimiter || ';';
+        delimiterResolved = true;
+      }
+      if (cleanLine.trim() === '') {
+        return null;
+      }
+      if (!headers) {
+        if (hasHeaders) {
+          headers = parseCsvLine(cleanLine, lineNumber, finalDelimiter).map(header => {
+            const trimmed = trim ? header.trim() : header;
+            return renameMap[trimmed] || trimmed;
+          });
+          return null;
+        }
+        const fields = parseCsvLine(cleanLine, lineNumber, finalDelimiter);
+        headers = fields.map((_, index) => `column${index + 1}`);
+        return processFields(fields);
+      }
+      const fields = parseCsvLine(cleanLine, lineNumber, finalDelimiter);
+      return processFields(fields);
+    };
+    while (true) {
+      const {
+        value,
+        done
+      } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, {
+        stream: true
+      });
+      let start = 0;
+      for (let i = 0; i < buffer.length; i++) {
+        const char = buffer[i];
+        if (char === '"') {
+          if (insideQuotes && buffer[i + 1] === '"') {
+            i++;
+            continue;
+          }
+          insideQuotes = !insideQuotes;
+          continue;
+        }
+        if (char === '\n' && !insideQuotes) {
+          const line = buffer.slice(start, i);
+          start = i + 1;
+          const row = processLine(line);
+          if (row) {
+            yield row;
+          }
+        }
+      }
+      buffer = buffer.slice(start);
+    }
+    if (buffer.length > 0) {
+      const row = processLine(buffer);
+      if (row) {
+        yield row;
+      }
+    }
+    if (insideQuotes) {
+      throw new ParsingError('Unclosed quotes in CSV', lineNumber);
+    }
+  }
 
   // Экспорт для Node.js совместимости
   if (typeof module !== 'undefined' && module.exports) {
     module.exports = {
       csvToJson,
-      autoDetectDelimiter
+      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) {
+        try {
+          const {
+            value,
+            done
+          } = await iterator.next();
+          if (done) {
+            controller.close();
+            return;
+          }
+          controller.enqueue(value);
+        } catch (error) {
+          controller.error(error);
+        }
+      },
+      cancel() {
+        if (iterator.return) {
+          iterator.return();
+        }
+      }
+    });
+  }
+  function detectInputFormat(input, options) {
+    if (options && options.inputFormat) {
+      return options.inputFormat;
+    }
+    if (typeof input === 'string') {
+      const trimmed = input.trim();
+      if (trimmed.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
     };
   }
 
@@ -1040,6 +1603,26 @@
     });
   }
 
+  /**
+   * 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 вместо автоматического скачивания
@@ -1089,8 +1672,12 @@
     module.exports = {
       downloadAsCsv,
       parseCsvFile,
+      parseCsvFileStream,
       createCsvBlob,
-      parseCsvBlob
+      parseCsvBlob,
+      jsonToCsvStream,
+      jsonToNdjsonStream,
+      csvToJsonStream
     };
   }
 
@@ -1100,44 +1687,74 @@
 
   // Проверка поддержки 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} WorkerPoolOptions
+   * @property {number} [workerCount=4] - Количество workers в pool
+   * @property {number} [maxQueueSize=100] - Максимальный размер очереди задач
+   * @property {boolean} [autoScale=true] - Автоматическое масштабирование pool
+   * @property {number} [idleTimeout=60000] - Таймаут простоя worker (мс)
    */
 
-  /**
-   * Статистика Worker Pool
-   * @typedef {Object} WorkerPoolStats
-   * @property {number} totalWorkers - Всего workers
-   * @property {number} activeWorkers - Активные workers
-   * @property {number} idleWorkers - Простаивающие workers
-   * @property {number} queueSize - Размер очереди
-   * @property {number} tasksCompleted - Завершенные задачи
-   * @property {number} tasksFailed - Неудачные задачи
+  /**
+   * Статистика Worker Pool
+   * @typedef {Object} WorkerPoolStats
+   * @property {number} totalWorkers - Всего workers
+   * @property {number} activeWorkers - Активные workers
+   * @property {number} idleWorkers - Простаивающие workers
+   * @property {number} queueSize - Размер очереди
+   * @property {number} tasksCompleted - Завершенные задачи
+   * @property {number} tasksFailed - Неудачные задачи
    */
 
-  /**
-   * Прогресс обработки задачи
-   * @typedef {Object} TaskProgress
-   * @property {number} processed - Обработано элементов
-   * @property {number} total - Всего элементов
-   * @property {number} percentage - Процент выполнения
-   * @property {number} speed - Скорость обработки (элементов/сек)
+  /**
+   * Прогресс обработки задачи
+   * @typedef {Object} TaskProgress
+   * @property {number} processed - Обработано элементов
+   * @property {number} total - Всего элементов
+   * @property {number} percentage - Процент выполнения
+   * @property {number} speed - Скорость обработки (элементов/сек)
    */
 
-  /**
-   * Worker Pool для параллельной обработки CSV
+  /**
+   * Worker Pool для параллельной обработки CSV
    */
   class WorkerPool {
-    /**
-     * Создает новый Worker Pool
-     * @param {string} workerScript - URL скрипта worker
-     * @param {WorkerPoolOptions} [options] - Опции pool
+    /**
+     * Создает новый Worker Pool
+     * @param {string} workerScript - URL скрипта worker
+     * @param {WorkerPoolOptions} [options] - Опции pool
      */
     constructor(workerScript, options = {}) {
       if (!WORKERS_SUPPORTED) {
@@ -1165,9 +1782,9 @@
       this.initializeWorkers();
     }
 
-    /**
-     * Инициализация workers
-     * @private
+    /**
+     * Инициализация workers
+     * @private
      */
     initializeWorkers() {
       const {
@@ -1179,9 +1796,9 @@
       this.updateStats();
     }
 
-    /**
-     * Создает нового worker
-     * @private
+    /**
+     * Создает нового worker
+     * @private
      */
     createWorker() {
       try {
@@ -1206,9 +1823,9 @@
       }
     }
 
-    /**
-     * Обработка сообщений от worker
-     * @private
+    /**
+     * Обработка сообщений от worker
+     * @private
      */
     handleWorkerMessage(worker, event) {
       const {
@@ -1223,9 +1840,9 @@
       }
     }
 
-    /**
-     * Обработка прогресса задачи
-     * @private
+    /**
+     * Обработка прогресса задачи
+     * @private
      */
     handleProgress(worker, progressData) {
       const taskId = worker.taskId;
@@ -1242,9 +1859,9 @@
       }
     }
 
-    /**
-     * Обработка результата задачи
-     * @private
+    /**
+     * Обработка результата задачи
+     * @private
      */
     handleResult(worker, resultData) {
       const taskId = worker.taskId;
@@ -1269,9 +1886,9 @@
       }
     }
 
-    /**
-     * Обработка ошибки задачи
-     * @private
+    /**
+     * Обработка ошибки задачи
+     * @private
      */
     handleWorkerTaskError(worker, errorData) {
       const taskId = worker.taskId;
@@ -1286,7 +1903,14 @@
         this.stats.idleWorkers++;
 
         // Завершение с ошибкой
-        task.reject(new Error(errorData.message || 'Ошибка в worker'));
+        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++;
 
@@ -1296,9 +1920,9 @@
       }
     }
 
-    /**
-     * Обработка ошибок worker
-     * @private
+    /**
+     * Обработка ошибок worker
+     * @private
      */
     handleWorkerError(worker, error) {
       console.error(`Worker ${worker.id} error:`, error);
@@ -1307,17 +1931,17 @@
       this.restartWorker(worker);
     }
 
-    /**
-     * Обработка ошибок сообщений
-     * @private
+    /**
+     * Обработка ошибок сообщений
+     * @private
      */
     handleWorkerMessageError(worker, error) {
       console.error(`Worker ${worker.id} message error:`, error);
     }
 
-    /**
-     * Перезапуск worker
-     * @private
+    /**
+     * Перезапуск worker
+     * @private
      */
     restartWorker(worker) {
       const index = this.workers.indexOf(worker);
@@ -1345,9 +1969,9 @@
       }
     }
 
-    /**
-     * Выполнение задачи на worker
-     * @private
+    /**
+     * Выполнение задачи на worker
+     * @private
      */
     executeTask(worker, task) {
       worker.status = 'active';
@@ -1357,59 +1981,59 @@
       this.stats.activeWorkers++;
 
       // Отправка задачи в worker
-      worker.postMessage({
+      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
+    /**
+     * Обработка очереди задач
+     * @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();
+      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;
         }
-        return;
+        const task = this.taskQueue.shift();
+        this.stats.queueSize--;
+        this.executeTask(idleWorker, task);
       }
-
-      // Получение задачи из очереди
-      const task = this.taskQueue.shift();
-      this.stats.queueSize--;
-
-      // Выполнение задачи
-      this.executeTask(idleWorker, task);
       this.updateStats();
     }
 
-    /**
-     * Обновление статистики
-     * @private
+    /**
+     * Обновление статистики
+     * @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>} Результат выполнения
+    /**
+     * Выполнение задачи через 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) => {
@@ -1421,11 +2045,17 @@
 
         // Создание задачи
         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,
+          options: taskOptions,
+          transferList,
           onProgress,
           resolve,
           reject,
@@ -1442,9 +2072,9 @@
       });
     }
 
-    /**
-     * Получение статистики pool
-     * @returns {WorkerPoolStats} Статистика
+    /**
+     * Получение статистики pool
+     * @returns {WorkerPoolStats} Статистика
      */
     getStats() {
       return {
@@ -1452,8 +2082,8 @@
       };
     }
 
-    /**
-     * Очистка простаивающих workers
+    /**
+     * Очистка простаивающих workers
      */
     cleanupIdleWorkers() {
       const now = Date.now();
@@ -1474,8 +2104,8 @@
       }
     }
 
-    /**
-     * Завершение всех workers
+    /**
+     * Завершение всех workers
      */
     terminate() {
       this.workers.forEach(worker => {
@@ -1497,10 +2127,10 @@
     }
   }
 
-  /**
-   * Создает Worker Pool для обработки CSV
-   * @param {WorkerPoolOptions} [options] - Опции pool
-   * @returns {WorkerPool} Worker Pool
+  /**
+   * Создает Worker Pool для обработки CSV
+   * @param {WorkerPoolOptions} [options] - Опции pool
+   * @returns {WorkerPool} Worker Pool
    */
   function createWorkerPool(options = {}) {
     // Используем встроенный worker скрипт
@@ -1508,12 +2138,12 @@
     return new WorkerPool(workerScript, options);
   }
 
-  /**
-   * Парсит CSV с использованием Web Workers
-   * @param {string|File} csvInput - CSV строка или File объект
-   * @param {Object} [options] - Опции парсинга
-   * @param {Function} [onProgress] - Callback прогресса
-   * @returns {Promise<Array<Object>>} JSON данные
+  /**
+   * Парсит CSV с использованием Web Workers
+   * @param {string|File} csvInput - CSV строка или File объект
+   * @param {Object} [options] - Опции парсинга
+   * @param {Function} [onProgress] - Callback прогресса
+   * @returns {Promise<Array<Object>>} JSON данные
    */
   async function parseCSVWithWorker(csvInput, options = {}, onProgress = null) {
     // Создание pool если нужно
@@ -1523,29 +2153,42 @@
     const pool = parseCSVWithWorker.pool;
 
     // Подготовка CSV строки
-    let csvString;
+    // ?????????? CSV ??????
+    let csvPayload = csvInput;
+    let transfer = null;
     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');
+      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
-    return pool.exec('parseCSV', [csvString, options], {}, onProgress);
+    // ????????? ?????? ????? pool
+    const execOptions = transfer ? {
+      transfer
+    } : {};
+    return pool.exec('parseCSV', [csvPayload, options], execOptions, onProgress);
   }
 
-  /**
-   * Чтение файла как текст
-   * @private
+  /**
+   * Чтение файла как текст
+   * @private
    */
-  async function readFileAsText(file) {
+  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.readAsText(file, 'UTF-8');
+      reader.readAsArrayBuffer(file);
     });
   }
 
@@ -1558,9 +2201,24 @@
     };
   }
 
+  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 = {
@@ -1571,11 +2229,18 @@
     deepUnwrap,
     // CSV to JSON функции
     csvToJson,
+    csvToJsonIterator,
     parseCsvFile,
+    parseCsvFileStream,
+    jsonToCsvStream,
+    jsonToNdjsonStream,
+    csvToJsonStream,
     autoDetectDelimiter,
     // Web Workers функции
     createWorkerPool,
     parseCSVWithWorker,
+    createWorkerPoolLazy,
+    parseCSVWithWorkerLazy,
     // Error classes
     ValidationError,
     SecurityError,
@@ -1583,6 +2248,7 @@
     ParsingError,
     LimitError,
     ConfigurationError,
+    ERROR_CODES,
     // Удобные алиасы
     parse: csvToJson,
     unparse: jsonToCsv,
@@ -1603,6 +2269,7 @@
   }
 
   exports.ConfigurationError = ConfigurationError;
+  exports.ERROR_CODES = ERROR_CODES;
   exports.FileSystemError = FileSystemError;
   exports.LimitError = LimitError;
   exports.ParsingError = ParsingError;
@@ -1610,13 +2277,20 @@
   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 });