jtcsv 2.1.3 → 2.2.2

package/dist/jtcsv.esm.js

@@ -93,6 +93,22 @@ class ConfigurationError extends JTCSVError {
     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'
+};
 
 /**
  * Безопасное выполнение функции с обработкой ошибок
@@ -228,6 +244,7 @@ if (typeof module !== 'undefined' && module.exports) {
     ParsingError,
     LimitError,
     ConfigurationError,
+    ERROR_CODES,
     safeExecute,
     safeExecuteAsync
   };
@@ -511,15 +528,10 @@ if (typeof module !== 'undefined' && module.exports) {
 
 
 /**
- * Валидация 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');
@@ -547,9 +559,24 @@ function validateCsvInput(csv, options) {
   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
@@ -695,6 +722,78 @@ function parseCsvValue(value, options) {
   }
   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
@@ -770,7 +869,8 @@ function csvToJson(csv, options = {}) {
       trim = true,
       parseNumbers = false,
       parseBooleans = false,
-      maxRows
+      maxRows,
+      warnExtraFields = true
     } = opts;
 
     // Определение разделителя
@@ -784,6 +884,16 @@ function csvToJson(csv, options = {}) {
     if (csv.trim() === '') {
       return [];
     }
+    if (isSimpleCsv(csv)) {
+      return parseSimpleCsv(csv, finalDelimiter, {
+        hasHeaders,
+        renameMap,
+        trim,
+        parseNumbers,
+        parseBooleans,
+        maxRows
+      });
+    }
 
     // Парсинг CSV с обработкой кавычек и переносов строк
     const lines = [];
@@ -887,7 +997,8 @@ function csvToJson(csv, options = {}) {
         }
 
         // Предупреждение о лишних полях
-        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);
@@ -903,12 +1014,464 @@ function csvToJson(csv, options = {}) {
     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
   };
 }
 
@@ -1033,6 +1596,26 @@ async function parseCsvFile(file, options = {}) {
   });
 }
 
+/**
+ * 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 вместо автоматического скачивания
@@ -1082,8 +1665,12 @@ if (typeof module !== 'undefined' && module.exports) {
   module.exports = {
     downloadAsCsv,
     parseCsvFile,
+    parseCsvFileStream,
     createCsvBlob,
-    parseCsvBlob
+    parseCsvBlob,
+    jsonToCsvStream,
+    jsonToNdjsonStream,
+    csvToJsonStream
   };
 }
 
@@ -1093,44 +1680,74 @@ if (typeof module !== 'undefined' && module.exports) {
 
 // Проверка поддержки 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) {
@@ -1158,9 +1775,9 @@ class WorkerPool {
     this.initializeWorkers();
   }
 
-  /**
-   * Инициализация workers
-   * @private
+  /**
+   * Инициализация workers
+   * @private
    */
   initializeWorkers() {
     const {
@@ -1172,9 +1789,9 @@ class WorkerPool {
     this.updateStats();
   }
 
-  /**
-   * Создает нового worker
-   * @private
+  /**
+   * Создает нового worker
+   * @private
    */
   createWorker() {
     try {
@@ -1199,9 +1816,9 @@ class WorkerPool {
     }
   }
 
-  /**
-   * Обработка сообщений от worker
-   * @private
+  /**
+   * Обработка сообщений от worker
+   * @private
    */
   handleWorkerMessage(worker, event) {
     const {
@@ -1216,9 +1833,9 @@ class WorkerPool {
     }
   }
 
-  /**
-   * Обработка прогресса задачи
-   * @private
+  /**
+   * Обработка прогресса задачи
+   * @private
    */
   handleProgress(worker, progressData) {
     const taskId = worker.taskId;
@@ -1235,9 +1852,9 @@ class WorkerPool {
     }
   }
 
-  /**
-   * Обработка результата задачи
-   * @private
+  /**
+   * Обработка результата задачи
+   * @private
    */
   handleResult(worker, resultData) {
     const taskId = worker.taskId;
@@ -1262,9 +1879,9 @@ class WorkerPool {
     }
   }
 
-  /**
-   * Обработка ошибки задачи
-   * @private
+  /**
+   * Обработка ошибки задачи
+   * @private
    */
   handleWorkerTaskError(worker, errorData) {
     const taskId = worker.taskId;
@@ -1279,7 +1896,14 @@ class WorkerPool {
       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++;
 
@@ -1289,9 +1913,9 @@ class WorkerPool {
     }
   }
 
-  /**
-   * Обработка ошибок worker
-   * @private
+  /**
+   * Обработка ошибок worker
+   * @private
    */
   handleWorkerError(worker, error) {
     console.error(`Worker ${worker.id} error:`, error);
@@ -1300,17 +1924,17 @@ class WorkerPool {
     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);
@@ -1338,9 +1962,9 @@ class WorkerPool {
     }
   }
 
-  /**
-   * Выполнение задачи на worker
-   * @private
+  /**
+   * Выполнение задачи на worker
+   * @private
    */
   executeTask(worker, task) {
     worker.status = 'active';
@@ -1350,59 +1974,59 @@ class WorkerPool {
     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) => {
@@ -1414,11 +2038,17 @@ class WorkerPool {
 
       // Создание задачи
       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,
@@ -1435,9 +2065,9 @@ class WorkerPool {
     });
   }
 
-  /**
-   * Получение статистики pool
-   * @returns {WorkerPoolStats} Статистика
+  /**
+   * Получение статистики pool
+   * @returns {WorkerPoolStats} Статистика
    */
   getStats() {
     return {
@@ -1445,8 +2075,8 @@ class WorkerPool {
     };
   }
 
-  /**
-   * Очистка простаивающих workers
+  /**
+   * Очистка простаивающих workers
    */
   cleanupIdleWorkers() {
     const now = Date.now();
@@ -1467,8 +2097,8 @@ class WorkerPool {
     }
   }
 
-  /**
-   * Завершение всех workers
+  /**
+   * Завершение всех workers
    */
   terminate() {
     this.workers.forEach(worker => {
@@ -1490,10 +2120,10 @@ class WorkerPool {
   }
 }
 
-/**
- * Создает 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 скрипт
@@ -1501,12 +2131,12 @@ function createWorkerPool(options = {}) {
   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 если нужно
@@ -1516,29 +2146,42 @@ async function parseCSVWithWorker(csvInput, options = {}, onProgress = null) {
   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);
   });
 }
 
@@ -1551,9 +2194,24 @@ if (typeof module !== 'undefined' && module.exports) {
   };
 }
 
+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 = {
@@ -1564,11 +2222,18 @@ const jtcsv = {
   deepUnwrap,
   // CSV to JSON функции
   csvToJson,
+  csvToJsonIterator,
   parseCsvFile,
+  parseCsvFileStream,
+  jsonToCsvStream,
+  jsonToNdjsonStream,
+  csvToJsonStream,
   autoDetectDelimiter,
   // Web Workers функции
   createWorkerPool,
   parseCSVWithWorker,
+  createWorkerPoolLazy,
+  parseCSVWithWorkerLazy,
   // Error classes
   ValidationError,
   SecurityError,
@@ -1576,6 +2241,7 @@ const jtcsv = {
   ParsingError,
   LimitError,
   ConfigurationError,
+  ERROR_CODES,
   // Удобные алиасы
   parse: csvToJson,
   unparse: jsonToCsv,
@@ -1595,5 +2261,5 @@ if (typeof module !== 'undefined' && module.exports) {
   window.jtcsv = jtcsv;
 }
 
-export { ConfigurationError, FileSystemError, LimitError, ParsingError, SecurityError, ValidationError, autoDetectDelimiter, createWorkerPool, csvToJson, deepUnwrap, jtcsv as default, downloadAsCsv, jsonToCsv, parseCSVWithWorker, parseCsvFile, preprocessData };
+export { ConfigurationError, ERROR_CODES, FileSystemError, LimitError, ParsingError, SecurityError, ValidationError, autoDetectDelimiter, createWorkerPool, createWorkerPoolLazy, csvToJson, csvToJsonIterator, csvToJsonStream, deepUnwrap, jtcsv as default, downloadAsCsv, jsonToCsv, jsonToCsvStream, jsonToNdjsonStream, parseCSVWithWorker, parseCSVWithWorkerLazy, parseCsvFile, parseCsvFileStream, preprocessData };
 //# sourceMappingURL=jtcsv.esm.js.map