jtcsv 2.2.8 → 3.1.0

package/dist/jtcsv-core.cjs.js

@@ -0,0 +1,1736 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// Система ошибок для браузерной версии jtcsv
+// Адаптирована для работы без Node.js специфичных API
+/**
+ * Базовый класс ошибки jtcsv
+ */
+class JTCSVError extends Error {
+    constructor(message, code = 'JTCSV_ERROR', details = {}) {
+        super(message);
+        this.name = 'JTCSVError';
+        this.code = code;
+        this.details = details;
+        this.hint = details.hint;
+        this.docs = details.docs;
+        this.context = details.context;
+        // Сохранение stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, JTCSVError);
+        }
+    }
+}
+/**
+ * Ошибка валидации
+ */
+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, 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, details = {}) {
+        super(message, 'PARSING_ERROR', { ...details, lineNumber });
+        this.name = 'ParsingError';
+        this.lineNumber = lineNumber;
+    }
+}
+/**
+ * Ошибка превышения лимита
+ */
+class LimitError extends JTCSVError {
+    constructor(message, limit, actual, details = {}) {
+        super(message, 'LIMIT_ERROR', { ...details, limit, actual });
+        this.name = 'LimitError';
+        this.limit = limit;
+        this.actual = actual;
+    }
+}
+/**
+ * Ошибка конфигурации
+ */
+class ConfigurationError extends JTCSVError {
+    constructor(message, details = {}) {
+        super(message, 'CONFIGURATION_ERROR', details);
+        this.name = 'ConfigurationError';
+    }
+}
+/**
+ * Коды ошибок
+ */
+const ERROR_CODES = {
+    JTCSV_ERROR: 'JTCSV_ERROR',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    SECURITY_ERROR: 'SECURITY_ERROR',
+    FILE_SYSTEM_ERROR: 'FILE_SYSTEM_ERROR',
+    PARSING_ERROR: 'PARSING_ERROR',
+    LIMIT_ERROR: 'LIMIT_ERROR',
+    CONFIGURATION_ERROR: 'CONFIGURATION_ERROR',
+    INVALID_INPUT: 'INVALID_INPUT',
+    SECURITY_VIOLATION: 'SECURITY_VIOLATION',
+    FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+    PARSE_FAILED: 'PARSE_FAILED',
+    SIZE_LIMIT: 'SIZE_LIMIT',
+    INVALID_CONFIG: 'INVALID_CONFIG',
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+};
+/**
+ * Безопасное выполнение функции с обработкой ошибок
+ *
+ * @param fn - Функция для выполнения
+ * @param errorCode - Код ошибки по умолчанию
+ * @param errorDetails - Детали ошибки
+ * @returns Результат выполнения функции
+ */
+function safeExecute(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
+    try {
+        if (typeof fn === 'function') {
+            return fn();
+        }
+        throw new ValidationError('Function expected');
+    }
+    catch (error) {
+        // Если ошибка уже является JTCSVError, перебросить её
+        if (error instanceof JTCSVError) {
+            throw error;
+        }
+        // Определить тип ошибки на основе сообщения или кода
+        let enhancedError;
+        const errorMessage = error.message || String(error);
+        if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
+            enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
+            enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
+            enhancedError = new ParsingError(errorMessage, undefined, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
+            enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
+            enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('file') || errorMessage.includes('File')) {
+            enhancedError = new FileSystemError(errorMessage, error, errorDetails);
+        }
+        else {
+            // Общая ошибка
+            enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error });
+        }
+        // Сохранить оригинальный stack trace если возможно
+        if (error.stack) {
+            enhancedError.stack = error.stack;
+        }
+        throw enhancedError;
+    }
+}
+/**
+ * Асинхронная версия safeExecute
+ */
+async function safeExecuteAsync(fn, errorCode = 'UNKNOWN_ERROR', errorDetails = {}) {
+    try {
+        if (typeof fn === 'function') {
+            return await fn();
+        }
+        throw new ValidationError('Function expected');
+    }
+    catch (error) {
+        // Если ошибка уже является JTCSVError, перебросить её
+        if (error instanceof JTCSVError) {
+            throw error;
+        }
+        // Определить тип ошибки
+        let enhancedError;
+        const errorMessage = error.message || String(error);
+        if (errorMessage.includes('validation') || errorMessage.includes('Validation')) {
+            enhancedError = new ValidationError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('security') || errorMessage.includes('Security')) {
+            enhancedError = new SecurityError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('parsing') || errorMessage.includes('Parsing')) {
+            enhancedError = new ParsingError(errorMessage, undefined, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('limit') || errorMessage.includes('Limit')) {
+            enhancedError = new LimitError(errorMessage, null, null, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('configuration') || errorMessage.includes('Configuration')) {
+            enhancedError = new ConfigurationError(errorMessage, { ...errorDetails, originalError: error });
+        }
+        else if (errorMessage.includes('file') || errorMessage.includes('File')) {
+            enhancedError = new FileSystemError(errorMessage, error, errorDetails);
+        }
+        else {
+            enhancedError = new JTCSVError(errorMessage, errorCode, { ...errorDetails, originalError: error });
+        }
+        if (error.stack) {
+            enhancedError.stack = error.stack;
+        }
+        throw enhancedError;
+    }
+}
+/**
+ * Создать сообщение об ошибке
+ */
+function createErrorMessage(error, includeStack = false) {
+    let message = error.message || 'Unknown error';
+    if (error instanceof JTCSVError) {
+        message = `[${error.code}] ${message}`;
+        if (error instanceof ParsingError && error.lineNumber) {
+            message += ` (line ${error.lineNumber})`;
+        }
+        if (error instanceof LimitError && error.limit && error.actual) {
+            message += ` (limit: ${error.limit}, actual: ${error.actual})`;
+        }
+        if (error.hint) {
+            message += `\nHint: ${error.hint}`;
+        }
+        if (error.docs) {
+            message += `\nDocs: ${error.docs}`;
+        }
+    }
+    if (includeStack && error.stack) {
+        message += `\n${error.stack}`;
+    }
+    return message;
+}
+/**
+ * Обработка ошибки
+ */
+function handleError(error, options = {}) {
+    const { log = true, throw: shouldThrow = false, format = true } = options;
+    const message = format ? createErrorMessage(error) : error.message;
+    if (log) {
+        console.error(`[jtcsv] ${message}`);
+        if (error instanceof JTCSVError && error.details) {
+            console.error('Error details:', error.details);
+        }
+    }
+    if (shouldThrow) {
+        throw error;
+    }
+    return message;
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        JTCSVError,
+        ValidationError,
+        SecurityError,
+        FileSystemError,
+        ParsingError,
+        LimitError,
+        ConfigurationError,
+        ERROR_CODES,
+        safeExecute,
+        safeExecuteAsync,
+        createErrorMessage,
+        handleError
+    };
+}
+
+// Браузерная версия JSON to CSV конвертера
+// Адаптирована для работы в браузере без Node.js API
+/**
+ * Валидация входных данных и опций
+ * @private
+ */
+function validateInput(data, options) {
+    // Validate data
+    if (!Array.isArray(data)) {
+        throw new ValidationError('Input data must be an array');
+    }
+    // Validate options
+    if (options && typeof options !== 'object') {
+        throw new ConfigurationError('Options must be an object');
+    }
+    // Validate delimiter
+    if (options?.delimiter && typeof options.delimiter !== 'string') {
+        throw new ConfigurationError('Delimiter must be a string');
+    }
+    if (options?.delimiter && options.delimiter.length !== 1) {
+        throw new ConfigurationError('Delimiter must be a single character');
+    }
+    // Validate renameMap
+    if (options?.renameMap && typeof options.renameMap !== 'object') {
+        throw new ConfigurationError('renameMap must be an object');
+    }
+    // Validate maxRecords
+    if (options && options.maxRecords !== undefined) {
+        if (typeof options.maxRecords !== 'number' || options.maxRecords <= 0) {
+            throw new ConfigurationError('maxRecords must be a positive number');
+        }
+    }
+    // Validate preventCsvInjection
+    if (options?.preventCsvInjection !== undefined && typeof options.preventCsvInjection !== 'boolean') {
+        throw new ConfigurationError('preventCsvInjection must be a boolean');
+    }
+    // Validate rfc4180Compliant
+    if (options?.rfc4180Compliant !== undefined && typeof options.rfc4180Compliant !== 'boolean') {
+        throw new ConfigurationError('rfc4180Compliant must be a boolean');
+    }
+    if (options?.normalizeQuotes !== undefined && typeof options.normalizeQuotes !== 'boolean') {
+        throw new ConfigurationError('normalizeQuotes must be a boolean');
+    }
+    return true;
+}
+/**
+ * Экранирование CSV значений для предотвращения инъекций
+ * @private
+ */
+function escapeCsvValue(value, preventInjection = true) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    const str = String(value);
+    const isPotentialFormula = (input) => {
+        let idx = 0;
+        while (idx < input.length) {
+            const code = input.charCodeAt(idx);
+            if (code === 32 || code === 9 || code === 10 || code === 13 || code === 0xfeff) {
+                idx++;
+                continue;
+            }
+            break;
+        }
+        if (idx < input.length && (input[idx] === '"' || input[idx] === "'")) {
+            idx++;
+            while (idx < input.length) {
+                const code = input.charCodeAt(idx);
+                if (code === 32 || code === 9) {
+                    idx++;
+                    continue;
+                }
+                break;
+            }
+        }
+        if (idx >= input.length) {
+            return false;
+        }
+        const char = input[idx];
+        return char === '=' || char === '+' || char === '-' || char === '@';
+    };
+    // Экранирование формул для предотвращения CSV инъекций
+    if (preventInjection && isPotentialFormula(str)) {
+        return "'" + str;
+    }
+    // Экранирование кавычек и переносов строк
+    if (str.includes('"') || str.includes('\n') || str.includes('\r') || str.includes(',')) {
+        return '"' + str.replace(/"/g, '""') + '"';
+    }
+    return str;
+}
+function normalizeQuotesInField$2(value) {
+    // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+    // Проверяем, выглядит ли значение как JSON (объект или массив)
+    if ((value.startsWith('{') && value.endsWith('}')) ||
+        (value.startsWith('[') && value.endsWith(']'))) {
+        return value; // Возвращаем как есть для JSON
+    }
+    let normalized = value.replace(/"{2,}/g, '"');
+    // Убираем правило, которое ломает JSON: не заменяем "," на ","
+    // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+    normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+    if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+        normalized = normalized.slice(1, -1);
+    }
+    return normalized;
+}
+function normalizePhoneValue$2(value) {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return trimmed;
+    }
+    return trimmed.replace(/["'\\]/g, '');
+}
+function normalizeValueForCsv$1(value, key, normalizeQuotes) {
+    if (!normalizeQuotes || typeof value !== 'string') {
+        return value;
+    }
+    const base = normalizeQuotesInField$2(value);
+    if (!key) {
+        return base;
+    }
+    const phoneKeys = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+    if (phoneKeys.has(String(key).toLowerCase())) {
+        return normalizePhoneValue$2(base);
+    }
+    return base;
+}
+/**
+ * Извлечение всех уникальных ключей из массива объектов
+ * @private
+ */
+function extractAllKeys(data) {
+    const keys = new Set();
+    for (const item of data) {
+        if (item && typeof item === 'object') {
+            Object.keys(item).forEach(key => keys.add(key));
+        }
+    }
+    return Array.from(keys);
+}
+/**
+ * Конвертация массива объектов в CSV строку
+ *
+ * @param data - Массив объектов для конвертации
+ * @param options - Опции конвертации
+ * @returns CSV строка
+ */
+function jsonToCsv$1(data, options = {}) {
+    return safeExecute(() => {
+        validateInput(data, options);
+        if (data.length === 0) {
+            return '';
+        }
+        // Настройки по умолчанию
+        const delimiter = options.delimiter || ';';
+        const includeHeaders = options.includeHeaders !== false;
+        const maxRecords = options.maxRecords || data.length;
+        const preventInjection = options.preventCsvInjection !== false;
+        const rfc4180Compliant = options.rfc4180Compliant !== false;
+        const normalizeQuotes = options.normalizeQuotes !== false;
+        // Ограничение количества записей
+        const limitedData = data.slice(0, maxRecords);
+        // Извлечение всех ключей
+        const allKeys = extractAllKeys(limitedData);
+        // Применение renameMap если есть
+        const renameMap = options.renameMap || {};
+        const finalKeys = allKeys.map(key => renameMap[key] || key);
+        // Создание CSV строки
+        const lines = [];
+        // Заголовки
+        if (includeHeaders) {
+            const headerLine = finalKeys.map(key => escapeCsvValue(key, preventInjection)).join(delimiter);
+            lines.push(headerLine);
+        }
+        // Данные
+        for (const item of limitedData) {
+            const rowValues = allKeys.map(key => {
+                const value = item?.[key];
+                const normalized = normalizeValueForCsv$1(value, key, normalizeQuotes);
+                return escapeCsvValue(normalized, preventInjection);
+            });
+            lines.push(rowValues.join(delimiter));
+        }
+        // RFC 4180 compliance: CRLF line endings
+        if (rfc4180Compliant) {
+            return lines.join('\r\n');
+        }
+        return lines.join('\n');
+    });
+}
+/**
+ * Асинхронная версия jsonToCsv
+ */
+async function jsonToCsvAsync$1(data, options = {}) {
+    return jsonToCsv$1(data, options);
+}
+/**
+ * Создает итератор для потоковой конвертации JSON в CSV
+ *
+ * @param data - Массив объектов или async итератор
+ * @param options - Опции конвертации
+ * @returns AsyncIterator с CSV чанками
+ */
+async function* jsonToCsvIterator(data, options = {}) {
+    validateInput(Array.isArray(data) ? data : [], options);
+    const delimiter = options.delimiter || ';';
+    const includeHeaders = options.includeHeaders !== false;
+    const preventInjection = options.preventCsvInjection !== false;
+    const rfc4180Compliant = options.rfc4180Compliant !== false;
+    const normalizeQuotes = options.normalizeQuotes !== false;
+    let allKeys = [];
+    let renameMap = {};
+    // Если данные - массив, обрабатываем как массив
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            return;
+        }
+        allKeys = extractAllKeys(data);
+        renameMap = options.renameMap || {};
+        const finalKeys = allKeys.map(key => renameMap[key] || key);
+        // Заголовки
+        if (includeHeaders) {
+            const headerLine = finalKeys.map(key => escapeCsvValue(key, preventInjection)).join(delimiter);
+            yield headerLine + (rfc4180Compliant ? '\r\n' : '\n');
+        }
+        // Данные
+        for (const item of data) {
+            const rowValues = allKeys.map(key => {
+                const value = item?.[key];
+                const normalized = normalizeValueForCsv$1(value, key, normalizeQuotes);
+                return escapeCsvValue(normalized, preventInjection);
+            });
+            yield rowValues.join(delimiter) + (rfc4180Compliant ? '\r\n' : '\n');
+        }
+    }
+    else {
+        // Для async итератора нужна другая логика
+        throw new ValidationError('Async iterators not yet implemented in browser version');
+    }
+}
+/**
+ * Асинхронная версия jsonToCsvIterator (псевдоним)
+ */
+const jsonToCsvIteratorAsync = jsonToCsvIterator;
+/**
+ * Безопасная конвертация с обработкой ошибок
+ *
+ * @param data - Массив объектов
+ * @param options - Опции конвертации
+ * @returns CSV строка или null при ошибке
+ */
+function jsonToCsvSafe(data, options = {}) {
+    try {
+        return jsonToCsv$1(data, options);
+    }
+    catch (error) {
+        console.error('JSON to CSV conversion error:', error);
+        return null;
+    }
+}
+/**
+ * Асинхронная версия jsonToCsvSafe
+ */
+async function jsonToCsvSafeAsync(data, options = {}) {
+    try {
+        return await jsonToCsvAsync$1(data, options);
+    }
+    catch (error) {
+        console.error('JSON to CSV conversion error:', error);
+        return null;
+    }
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        jsonToCsv: jsonToCsv$1,
+        jsonToCsvAsync: jsonToCsvAsync$1,
+        jsonToCsvIterator,
+        jsonToCsvIteratorAsync,
+        jsonToCsvSafe,
+        jsonToCsvSafeAsync
+    };
+}
+
+var jsonToCsvBrowser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    jsonToCsv: jsonToCsv$1,
+    jsonToCsvAsync: jsonToCsvAsync$1,
+    jsonToCsvIterator: jsonToCsvIterator,
+    jsonToCsvIteratorAsync: jsonToCsvIteratorAsync,
+    jsonToCsvSafe: jsonToCsvSafe,
+    jsonToCsvSafeAsync: jsonToCsvSafeAsync
+});
+
+// Браузерная версия CSV to JSON конвертера
+// Адаптирована для работы в браузере без Node.js API
+/**
+ * Валидация опций парсинга
+ * @private
+ */
+function validateCsvOptions(options) {
+    // Validate options
+    if (options && typeof options !== 'object') {
+        throw new ConfigurationError('Options must be an object');
+    }
+    // Validate delimiter
+    if (options?.delimiter && typeof options.delimiter !== 'string') {
+        throw new ConfigurationError('Delimiter must be a string');
+    }
+    if (options?.delimiter && options.delimiter.length !== 1) {
+        throw new ConfigurationError('Delimiter must be a single character');
+    }
+    // Validate autoDetect
+    if (options?.autoDetect !== undefined && typeof options.autoDetect !== 'boolean') {
+        throw new ConfigurationError('autoDetect must be a boolean');
+    }
+    // Validate candidates
+    if (options?.candidates && !Array.isArray(options.candidates)) {
+        throw new ConfigurationError('candidates must be an array');
+    }
+    // Validate maxRows
+    if (options?.maxRows !== undefined && (typeof options.maxRows !== 'number' || options.maxRows <= 0)) {
+        throw new ConfigurationError('maxRows must be a positive number');
+    }
+    if (options?.warnExtraFields !== undefined && typeof options.warnExtraFields !== 'boolean') {
+        throw new ConfigurationError('warnExtraFields must be a boolean');
+    }
+    if (options?.repairRowShifts !== undefined && typeof options.repairRowShifts !== 'boolean') {
+        throw new ConfigurationError('repairRowShifts must be a boolean');
+    }
+    if (options?.normalizeQuotes !== undefined && typeof options.normalizeQuotes !== 'boolean') {
+        throw new ConfigurationError('normalizeQuotes must be a boolean');
+    }
+    return true;
+}
+/**
+ * Автоматическое определение разделителя
+ * @private
+ */
+function autoDetectDelimiter$1(text, candidates = [',', ';', '\t', '|']) {
+    if (!text || typeof text !== 'string') {
+        return ',';
+    }
+    const firstLine = text.split('\n')[0];
+    if (!firstLine) {
+        return ',';
+    }
+    let bestCandidate = ',';
+    let bestCount = 0;
+    for (const candidate of candidates) {
+        const count = (firstLine.match(new RegExp(candidate.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
+        if (count > bestCount) {
+            bestCount = count;
+            bestCandidate = candidate;
+        }
+    }
+    return bestCandidate;
+}
+function isEmptyValue(value) {
+    return value === undefined || value === null || value === '';
+}
+function hasOddQuotes(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    let count = 0;
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === '"') {
+            count++;
+        }
+    }
+    return count % 2 === 1;
+}
+function hasAnyQuotes(value) {
+    return typeof value === 'string' && value.includes('"');
+}
+function normalizeQuotesInField$1(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+    // Проверяем, выглядит ли значение как JSON (объект или массив)
+    if ((value.startsWith('{') && value.endsWith('}')) ||
+        (value.startsWith('[') && value.endsWith(']'))) {
+        return value; // Возвращаем как есть для JSON
+    }
+    let normalized = value.replace(/"{2,}/g, '"');
+    // Убираем правило, которое ломает JSON: не заменяем "," на ","
+    // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+    normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+    if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+        normalized = normalized.slice(1, -1);
+    }
+    return normalized;
+}
+function normalizePhoneValue$1(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return trimmed;
+    }
+    return trimmed.replace(/["'\\]/g, '');
+}
+function normalizeRowQuotes(row, headers) {
+    const normalized = {};
+    const phoneKeys = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+    for (const header of headers) {
+        const baseValue = normalizeQuotesInField$1(row[header]);
+        if (phoneKeys.has(String(header).toLowerCase())) {
+            normalized[header] = normalizePhoneValue$1(baseValue);
+        }
+        else {
+            normalized[header] = baseValue;
+        }
+    }
+    return normalized;
+}
+function looksLikeUserAgent(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    return /Mozilla\/|Opera\/|MSIE|AppleWebKit|Gecko|Safari|Chrome\//.test(value);
+}
+function isHexColor(value) {
+    return typeof value === 'string' && /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
+}
+function repairShiftedRows(rows, headers, options = {}) {
+    if (!Array.isArray(rows) || rows.length === 0 || headers.length === 0) {
+        return rows;
+    }
+    const headerCount = headers.length;
+    const merged = [];
+    let index = 0;
+    while (index < rows.length) {
+        const row = rows[index];
+        if (!row || typeof row !== 'object') {
+            merged.push(row);
+            index++;
+            continue;
+        }
+        const values = headers.map((header) => row[header]);
+        let lastNonEmpty = -1;
+        for (let i = headerCount - 1; i >= 0; i--) {
+            if (!isEmptyValue(values[i])) {
+                lastNonEmpty = i;
+                break;
+            }
+        }
+        const missingCount = headerCount - 1 - lastNonEmpty;
+        if (lastNonEmpty >= 0 && missingCount > 0 && index + 1 < rows.length) {
+            const nextRow = rows[index + 1];
+            if (nextRow && typeof nextRow === 'object') {
+                const nextValues = headers.map((header) => nextRow[header]);
+                const nextTrailingEmpty = nextValues
+                    .slice(headerCount - missingCount)
+                    .every((value) => isEmptyValue(value));
+                const leadValues = nextValues
+                    .slice(0, missingCount)
+                    .filter((value) => !isEmptyValue(value));
+                const shouldMerge = nextTrailingEmpty
+                    && leadValues.length > 0
+                    && (hasOddQuotes(values[lastNonEmpty]) || hasAnyQuotes(values[lastNonEmpty]));
+                if (shouldMerge) {
+                    const toAppend = leadValues.map((value) => String(value));
+                    if (toAppend.length > 0) {
+                        const base = isEmptyValue(values[lastNonEmpty]) ? '' : String(values[lastNonEmpty]);
+                        values[lastNonEmpty] = base ? `${base}\n${toAppend.join('\n')}` : toAppend.join('\n');
+                    }
+                    for (let i = 0; i < missingCount; i++) {
+                        values[lastNonEmpty + 1 + i] = nextValues[missingCount + i];
+                    }
+                    const mergedRow = {};
+                    for (let i = 0; i < headerCount; i++) {
+                        mergedRow[headers[i]] = values[i];
+                    }
+                    merged.push(mergedRow);
+                    index += 2;
+                    continue;
+                }
+            }
+        }
+        if (index + 1 < rows.length && headerCount >= 6) {
+            const nextRow = rows[index + 1];
+            if (nextRow && typeof nextRow === 'object') {
+                const nextHex = nextRow[headers[4]];
+                const nextUserAgentHead = nextRow[headers[2]];
+                const nextUserAgentTail = nextRow[headers[3]];
+                const shouldMergeUserAgent = isEmptyValue(values[4])
+                    && isEmptyValue(values[5])
+                    && isHexColor(nextHex)
+                    && (looksLikeUserAgent(nextUserAgentHead) || looksLikeUserAgent(nextUserAgentTail));
+                if (shouldMergeUserAgent) {
+                    const addressParts = [values[3], nextRow[headers[0]], nextRow[headers[1]]]
+                        .filter((value) => !isEmptyValue(value))
+                        .map((value) => String(value));
+                    values[3] = addressParts.join('\n');
+                    const uaHead = isEmptyValue(nextUserAgentHead) ? '' : String(nextUserAgentHead);
+                    const uaTail = isEmptyValue(nextUserAgentTail) ? '' : String(nextUserAgentTail);
+                    const joiner = uaHead && uaTail ? (uaTail.startsWith(' ') ? '' : ',') : '';
+                    values[4] = uaHead + joiner + uaTail;
+                    values[5] = String(nextHex);
+                    const mergedRow = {};
+                    for (let i = 0; i < headerCount; i++) {
+                        mergedRow[headers[i]] = values[i];
+                    }
+                    merged.push(mergedRow);
+                    index += 2;
+                    continue;
+                }
+            }
+        }
+        merged.push(row);
+        index++;
+    }
+    if (options.normalizeQuotes) {
+        return merged.map((row) => normalizeRowQuotes(row, headers));
+    }
+    return merged;
+}
+/**
+ * Парсинг CSV строки в массив объектов
+ *
+ * @param csvText - CSV текст для парсинга
+ * @param options - Опции парсинга
+ * @returns Массив объектов
+ */
+function csvToJson$1(csvText, options = {}) {
+    return safeExecute(() => {
+        validateCsvOptions(options);
+        if (typeof csvText !== 'string') {
+            throw new ValidationError('CSV text must be a string');
+        }
+        if (csvText.trim() === '') {
+            return [];
+        }
+        // Определение разделителя
+        const delimiter = options.delimiter ||
+            (options.autoDetect !== false ? autoDetectDelimiter$1(csvText, options.candidates) : ',');
+        // Разделение на строки
+        const lines = csvText.split('\n').filter(line => line.trim() !== '');
+        if (lines.length === 0) {
+            return [];
+        }
+        // Парсинг заголовков
+        const headers = lines[0].split(delimiter).map(h => h.trim());
+        const { repairRowShifts = true, normalizeQuotes = true } = options || {};
+        // Ограничение количества строк
+        const maxRows = options.maxRows || Infinity;
+        const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
+        // Парсинг данных
+        const result = [];
+        for (let i = 0; i < dataRows.length; i++) {
+            const line = dataRows[i];
+            const values = line.split(delimiter);
+            const row = {};
+            for (let j = 0; j < headers.length; j++) {
+                const header = headers[j];
+                const value = j < values.length ? values[j].trim() : '';
+                // Попытка парсинга чисел
+                if (/^-?\d+(\.\d+)?$/.test(value)) {
+                    row[header] = parseFloat(value);
+                }
+                else if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
+                    row[header] = value.toLowerCase() === 'true';
+                }
+                else {
+                    row[header] = value;
+                }
+            }
+            result.push(row);
+        }
+        if (repairRowShifts) {
+            return repairShiftedRows(result, headers, { normalizeQuotes });
+        }
+        if (normalizeQuotes) {
+            return result.map((row) => normalizeRowQuotes(row, headers));
+        }
+        return result;
+    });
+}
+/**
+ * Асинхронная версия csvToJson
+ */
+async function csvToJsonAsync$1(csvText, options = {}) {
+    return csvToJson$1(csvText, options);
+}
+/**
+ * Создает итератор для потокового парсинга CSV
+ *
+ * @param input - CSV текст, File или Blob
+ * @param options - Опции парсинга
+ * @returns AsyncGenerator
+ */
+async function* csvToJsonIterator$1(input, options = {}) {
+    validateCsvOptions(options);
+    let csvText;
+    if (typeof input === 'string') {
+        csvText = input;
+    }
+    else if (input instanceof File || input instanceof Blob) {
+        csvText = await input.text();
+    }
+    else {
+        throw new ValidationError('Input must be string, File or Blob');
+    }
+    if (csvText.trim() === '') {
+        return;
+    }
+    // Определение разделителя
+    const delimiter = options.delimiter ||
+        (options.autoDetect !== false ? autoDetectDelimiter$1(csvText, options.candidates) : ',');
+    // Разделение на строки
+    const lines = csvText.split('\n').filter(line => line.trim() !== '');
+    if (lines.length === 0) {
+        return;
+    }
+    // Парсинг заголовков
+    const headers = lines[0].split(delimiter).map(h => h.trim());
+    const { repairRowShifts = true, normalizeQuotes = true } = options || {};
+    // Ограничение количества строк
+    const maxRows = options.maxRows || Infinity;
+    const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
+    // Возврат данных по одной строке
+    const parsedRows = [];
+    for (let i = 0; i < dataRows.length; i++) {
+        const line = dataRows[i];
+        const values = line.split(delimiter);
+        const row = {};
+        for (let j = 0; j < headers.length; j++) {
+            const header = headers[j];
+            const value = j < values.length ? values[j].trim() : '';
+            // Try parsing numbers
+            if (/^-?\d+(\.\d+)?$/.test(value)) {
+                row[header] = parseFloat(value);
+            }
+            else if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
+                row[header] = value.toLowerCase() === 'true';
+            }
+            else {
+                row[header] = value;
+            }
+        }
+        parsedRows.push(row);
+    }
+    const finalRows = repairRowShifts
+        ? repairShiftedRows(parsedRows, headers, { normalizeQuotes })
+        : (normalizeQuotes
+            ? parsedRows.map((row) => normalizeRowQuotes(row, headers))
+            : parsedRows);
+    for (const row of finalRows) {
+        yield row;
+    }
+}
+/**
+ * Асинхронная версия csvToJsonIterator (псевдоним)
+ */
+const csvToJsonIteratorAsync = csvToJsonIterator$1;
+/**
+ * Парсинг CSV с обработкой ошибок
+ *
+ * @param csvText - CSV текст
+ * @param options - Опции парсинга
+ * @returns Результат парсинга или null при ошибке
+ */
+function parseCsvSafe(csvText, options = {}) {
+    try {
+        return csvToJson$1(csvText, options);
+    }
+    catch (error) {
+        console.error('CSV parsing error:', error);
+        return null;
+    }
+}
+/**
+ * Асинхронная версия parseCsvSafe
+ */
+async function parseCsvSafeAsync(csvText, options = {}) {
+    try {
+        return await csvToJsonAsync$1(csvText, options);
+    }
+    catch (error) {
+        console.error('CSV parsing error:', error);
+        return null;
+    }
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        csvToJson: csvToJson$1,
+        csvToJsonAsync: csvToJsonAsync$1,
+        csvToJsonIterator: csvToJsonIterator$1,
+        csvToJsonIteratorAsync,
+        parseCsvSafe,
+        parseCsvSafeAsync,
+        autoDetectDelimiter: autoDetectDelimiter$1
+    };
+}
+
+var csvToJsonBrowser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    csvToJson: csvToJson$1,
+    csvToJsonAsync: csvToJsonAsync$1,
+    csvToJsonIterator: csvToJsonIterator$1,
+    csvToJsonIteratorAsync: csvToJsonIteratorAsync,
+    parseCsvSafe: parseCsvSafe,
+    parseCsvSafeAsync: parseCsvSafeAsync
+});
+
+const PHONE_KEYS = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+function isReadableStream(value) {
+    return value && typeof value.getReader === 'function';
+}
+function isAsyncIterable(value) {
+    return value && typeof value[Symbol.asyncIterator] === 'function';
+}
+function isIterable(value) {
+    return value && typeof value[Symbol.iterator] === 'function';
+}
+function createReadableStreamFromIterator(iterator) {
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const { value, done } = await iterator.next();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        cancel() {
+            if (iterator.return) {
+                iterator.return();
+            }
+        }
+    });
+}
+function detectInputFormat(input, options) {
+    if (options && options.inputFormat) {
+        return options.inputFormat;
+    }
+    if (typeof input === 'string') {
+        const trimmed = input.trim();
+        if (trimmed === '') {
+            return 'unknown';
+        }
+        // Проверка на NDJSON (каждая строка - валидный JSON)
+        if (trimmed.includes('\n')) {
+            const lines = trimmed.split('\n').filter(line => line.trim() !== '');
+            if (lines.length > 0) {
+                try {
+                    JSON.parse(lines[0]);
+                    return 'ndjson';
+                }
+                catch {
+                    // Не NDJSON
+                }
+            }
+        }
+        // Проверка на JSON
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed) || (parsed && typeof parsed === 'object')) {
+                return 'json';
+            }
+        }
+        catch {
+            // Не JSON
+        }
+        // Проверка на CSV
+        if (trimmed.includes(',') || trimmed.includes(';') || trimmed.includes('\t')) {
+            return 'csv';
+        }
+    }
+    return 'unknown';
+}
+function normalizeQuotesInField(value) {
+    // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+    // Проверяем, выглядит ли значение как JSON (объект или массив)
+    if ((value.startsWith('{') && value.endsWith('}')) ||
+        (value.startsWith('[') && value.endsWith(']'))) {
+        return value; // Возвращаем как есть для JSON
+    }
+    let normalized = value.replace(/"{2,}/g, '"');
+    // Убираем правило, которое ломает JSON: не заменяем "," на ","
+    // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+    normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+    if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+        normalized = normalized.slice(1, -1);
+    }
+    return normalized;
+}
+function normalizePhoneValue(value) {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return trimmed;
+    }
+    return trimmed.replace(/["'\\]/g, '');
+}
+function normalizeValueForCsv(value, key, normalizeQuotes) {
+    if (!normalizeQuotes || typeof value !== 'string') {
+        return value;
+    }
+    const base = normalizeQuotesInField(value);
+    if (key && PHONE_KEYS.has(String(key).toLowerCase())) {
+        return normalizePhoneValue(base);
+    }
+    return base;
+}
+async function* jsonToCsvChunkIterator(input, options = {}) {
+    const format = detectInputFormat(input, options);
+    if (format === 'csv') {
+        throw new ValidationError('Input appears to be CSV, not JSON');
+    }
+    // Вспомогательная функция для создания асинхронного итератора
+    function toAsyncIterator(iterable) {
+        if (isAsyncIterable(iterable)) {
+            return iterable[Symbol.asyncIterator]();
+        }
+        if (isIterable(iterable)) {
+            const syncIterator = iterable[Symbol.iterator]();
+            return {
+                next: () => Promise.resolve(syncIterator.next()),
+                return: syncIterator.return ? () => Promise.resolve(syncIterator.return()) : undefined,
+                throw: syncIterator.throw ? (error) => Promise.resolve(syncIterator.throw(error)) : undefined
+            };
+        }
+        throw new ValidationError('Input is not iterable');
+    }
+    let iterator;
+    if (isAsyncIterable(input) || isIterable(input)) {
+        iterator = toAsyncIterator(input);
+    }
+    else if (typeof input === 'string') {
+        const parsed = JSON.parse(input);
+        if (Array.isArray(parsed)) {
+            iterator = toAsyncIterator(parsed);
+        }
+        else {
+            iterator = toAsyncIterator([parsed]);
+        }
+    }
+    else if (Array.isArray(input)) {
+        iterator = toAsyncIterator(input);
+    }
+    else {
+        iterator = toAsyncIterator([input]);
+    }
+    const delimiter = options.delimiter || ';';
+    const includeHeaders = options.includeHeaders !== false;
+    const preventInjection = options.preventCsvInjection !== false;
+    const normalizeQuotes = options.normalizeQuotes !== false;
+    const isPotentialFormula = (input) => {
+        let idx = 0;
+        while (idx < input.length) {
+            const code = input.charCodeAt(idx);
+            if (code === 32 || code === 9 || code === 10 || code === 13 || code === 0xfeff) {
+                idx++;
+                continue;
+            }
+            break;
+        }
+        if (idx < input.length && (input[idx] === '"' || input[idx] === "'")) {
+            idx++;
+            while (idx < input.length) {
+                const code = input.charCodeAt(idx);
+                if (code === 32 || code === 9) {
+                    idx++;
+                    continue;
+                }
+                break;
+            }
+        }
+        if (idx >= input.length) {
+            return false;
+        }
+        const char = input[idx];
+        return char === '=' || char === '+' || char === '-' || char === '@';
+    };
+    let isFirstChunk = true;
+    let headers = [];
+    while (true) {
+        const { value, done } = await iterator.next();
+        if (done)
+            break;
+        const item = value;
+        if (isFirstChunk) {
+            // Извлечение заголовков из первого элемента
+            headers = Object.keys(item);
+            if (includeHeaders) {
+                const headerLine = headers.map(header => {
+                    const escaped = header.includes('"') ? `"${header.replace(/"/g, '""')}"` : header;
+                    return preventInjection && isPotentialFormula(escaped) ? `'${escaped}` : escaped;
+                }).join(delimiter);
+                yield headerLine + '\n';
+            }
+            isFirstChunk = false;
+        }
+        const row = headers.map(header => {
+            const value = item[header];
+            const normalized = normalizeValueForCsv(value, header, normalizeQuotes);
+            const strValue = normalized === null || normalized === undefined ? '' : String(normalized);
+            if (strValue.includes('"') || strValue.includes('\n') || strValue.includes('\r') || strValue.includes(delimiter)) {
+                return `"${strValue.replace(/"/g, '""')}"`;
+            }
+            if (preventInjection && isPotentialFormula(strValue)) {
+                return `'${strValue}`;
+            }
+            return strValue;
+        }).join(delimiter);
+        yield row + '\n';
+    }
+}
+async function* jsonToNdjsonChunkIterator(input, options = {}) {
+    const format = detectInputFormat(input, options);
+    // Вспомогательная функция для создания асинхронного итератора
+    function toAsyncIterator(iterable) {
+        if (isAsyncIterable(iterable)) {
+            return iterable[Symbol.asyncIterator]();
+        }
+        if (isIterable(iterable)) {
+            const syncIterator = iterable[Symbol.iterator]();
+            return {
+                next: () => Promise.resolve(syncIterator.next()),
+                return: syncIterator.return ? () => Promise.resolve(syncIterator.return()) : undefined,
+                throw: syncIterator.throw ? (error) => Promise.resolve(syncIterator.throw(error)) : undefined
+            };
+        }
+        throw new ValidationError('Input is not iterable');
+    }
+    let iterator;
+    if (isAsyncIterable(input) || isIterable(input)) {
+        iterator = toAsyncIterator(input);
+    }
+    else if (typeof input === 'string') {
+        if (format === 'ndjson') {
+            const lines = input.split('\n').filter(line => line.trim() !== '');
+            iterator = toAsyncIterator(lines);
+        }
+        else {
+            const parsed = JSON.parse(input);
+            if (Array.isArray(parsed)) {
+                iterator = toAsyncIterator(parsed);
+            }
+            else {
+                iterator = toAsyncIterator([parsed]);
+            }
+        }
+    }
+    else if (Array.isArray(input)) {
+        iterator = toAsyncIterator(input);
+    }
+    else {
+        iterator = toAsyncIterator([input]);
+    }
+    while (true) {
+        const { value, done } = await iterator.next();
+        if (done)
+            break;
+        let jsonStr;
+        if (typeof value === 'string') {
+            try {
+                // Проверяем, является ли строка валидным JSON
+                JSON.parse(value);
+                jsonStr = value;
+            }
+            catch {
+                // Если нет, сериализуем как JSON
+                jsonStr = JSON.stringify(value);
+            }
+        }
+        else {
+            jsonStr = JSON.stringify(value);
+        }
+        yield jsonStr + '\n';
+    }
+}
+async function* csvToJsonChunkIterator(input, options = {}) {
+    if (typeof input === 'string') {
+        // Используем csvToJsonIterator из csv-to-json-browser
+        yield* csvToJsonIterator$1(input, options);
+    }
+    else if (input instanceof File || input instanceof Blob) {
+        const text = await input.text();
+        yield* csvToJsonIterator$1(text, options);
+    }
+    else if (isReadableStream(input)) {
+        const reader = input.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Обработка буфера по строкам
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                // TODO: Реализовать парсинг CSV из чанков
+                // Пока просто возвращаем сырые строки
+                for (const line of lines) {
+                    if (line.trim()) {
+                        yield { raw: line };
+                    }
+                }
+            }
+            // Обработка остатка буфера
+            if (buffer.trim()) {
+                yield { raw: buffer };
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    else {
+        throw new ValidationError('Unsupported input type for CSV streaming');
+    }
+}
+function jsonToCsvStream$1(input, options = {}) {
+    const iterator = jsonToCsvChunkIterator(input, options);
+    return createReadableStreamFromIterator(iterator);
+}
+function jsonToNdjsonStream$1(input, options = {}) {
+    const iterator = jsonToNdjsonChunkIterator(input, options);
+    return createReadableStreamFromIterator(iterator);
+}
+function csvToJsonStream$1(input, options = {}) {
+    const iterator = csvToJsonChunkIterator(input, options);
+    return createReadableStreamFromIterator(iterator);
+}
+/**
+ * Асинхронная версия jsonToCsvStream
+ */
+async function jsonToCsvStreamAsync(input, options = {}) {
+    return jsonToCsvStream$1(input, options);
+}
+/**
+ * Асинхронная версия jsonToNdjsonStream
+ */
+async function jsonToNdjsonStreamAsync(input, options = {}) {
+    return jsonToNdjsonStream$1(input, options);
+}
+/**
+ * Асинхронная версия csvToJsonStream
+ */
+async function csvToJsonStreamAsync(input, options = {}) {
+    return csvToJsonStream$1(input, options);
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        jsonToCsvStream: jsonToCsvStream$1,
+        jsonToCsvStreamAsync,
+        jsonToNdjsonStream: jsonToNdjsonStream$1,
+        jsonToNdjsonStreamAsync,
+        csvToJsonStream: csvToJsonStream$1,
+        csvToJsonStreamAsync,
+        createReadableStreamFromIterator
+    };
+}
+
+// Браузерные специфичные функции для jtcsv
+// Функции, которые работают только в браузере
+/**
+ * Скачивает JSON данные как CSV файл
+ *
+ * @param data - Массив объектов для конвертации
+ * @param filename - Имя файла для скачивания (по умолчанию 'data.csv')
+ * @param options - Опции для jsonToCsv
+ *
+ * @example
+ * const data = [
+ *   { id: 1, name: 'John' },
+ *   { id: 2, name: 'Jane' }
+ * ];
+ * downloadAsCsv(data, 'users.csv', { delimiter: ',' });
+ */
+function downloadAsCsv(data, filename = 'data.csv', options = {}) {
+    // Проверка что мы в браузере
+    if (typeof window === 'undefined') {
+        throw new ValidationError('downloadAsCsv() работает только в браузере. Используйте saveAsCsv() в Node.js');
+    }
+    // Валидация имени файла
+    if (typeof filename !== 'string' || filename.trim() === '') {
+        throw new ValidationError('Filename must be a non-empty string');
+    }
+    // Добавление расширения .csv если его нет
+    if (!filename.toLowerCase().endsWith('.csv')) {
+        filename += '.csv';
+    }
+    // Конвертация в CSV
+    const csv = jsonToCsv$1(data, options);
+    // Создание Blob
+    const blob = new Blob([csv], {
+        type: 'text/csv;charset=utf-8;'
+    });
+    // Создание ссылки для скачивания
+    const link = document.createElement('a');
+    const url = URL.createObjectURL(blob);
+    link.setAttribute('href', url);
+    link.setAttribute('download', filename);
+    link.style.visibility = 'hidden';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    // Освобождение URL
+    setTimeout(() => URL.revokeObjectURL(url), 100);
+}
+/**
+ * Асинхронная версия downloadAsCsv
+ */
+async function downloadAsCsvAsync$1(data, filename = 'data.csv', options = {}) {
+    return downloadAsCsv(data, filename, options);
+}
+/**
+ * Парсит CSV файл из input[type="file"]
+ *
+ * @param file - File объект из input
+ * @param options - Опции для csvToJson
+ * @returns Promise с распарсенными данными
+ */
+async function parseCsvFile(file, options = {}) {
+    if (!(file instanceof File)) {
+        throw new ValidationError('parseCsvFile() ожидает объект File');
+    }
+    // Чтение файла как текст
+    const text = await file.text();
+    // Парсинг CSV
+    return csvToJson$1(text, options);
+}
+/**
+ * Парсит CSV файл потоково
+ *
+ * @param file - File объект
+ * @param options - Опции для потокового парсинга
+ * @returns AsyncIterator с данными
+ */
+function parseCsvFileStream(file, options = {}) {
+    if (!(file instanceof File)) {
+        throw new ValidationError('parseCsvFileStream() ожидает объект File');
+    }
+    // Используем csvToJsonIterator из импортированного модуля
+    return csvToJsonIterator$1(file, options);
+}
+/**
+ * Создает поток для конвертации JSON в CSV
+ *
+ * @param options - Опции для jsonToCsv
+ * @returns ReadableStream
+ */
+function jsonToCsvStream(options = {}) {
+    return jsonToCsvStream$1(options);
+}
+/**
+ * Создает поток для конвертации JSON в NDJSON
+ *
+ * @param options - Опции для конвертации
+ * @returns ReadableStream
+ */
+function jsonToNdjsonStream(options = {}) {
+    return jsonToNdjsonStream$1(options);
+}
+/**
+ * Создает поток для парсинга CSV в JSON
+ *
+ * @param options - Опции для csvToJson
+ * @returns ReadableStream
+ */
+function csvToJsonStream(options = {}) {
+    return csvToJsonStream$1(options);
+}
+/**
+ * Загружает CSV файл по URL
+ *
+ * @param url - URL CSV файла
+ * @param options - Опции для csvToJson
+ * @returns Promise с распарсенными данными
+ */
+async function loadCsvFromUrl(url, options = {}) {
+    if (typeof window === 'undefined') {
+        throw new ValidationError('loadCsvFromUrl() работает только в браузере');
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new ValidationError(`Failed to load CSV from URL: ${response.status} ${response.statusText}`);
+    }
+    const text = await response.text();
+    return csvToJson$1(text, options);
+}
+/**
+ * Асинхронная версия loadCsvFromUrl
+ */
+async function loadCsvFromUrlAsync(url, options = {}) {
+    return loadCsvFromUrl(url, options);
+}
+/**
+ * Экспортирует данные в CSV и открывает в новой вкладке
+ *
+ * @param data - Данные для экспорта
+ * @param options - Опции для jsonToCsv
+ */
+function openCsvInNewTab(data, options = {}) {
+    if (typeof window === 'undefined') {
+        throw new ValidationError('openCsvInNewTab() работает только в браузере');
+    }
+    const csv = jsonToCsv$1(data, options);
+    const blob = new Blob([csv], { type: 'text/csv;charset=utf-8' });
+    const url = URL.createObjectURL(blob);
+    window.open(url, '_blank');
+    // Освобождение URL через некоторое время
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+}
+/**
+ * Асинхронная версия openCsvInNewTab
+ */
+async function openCsvInNewTabAsync(data, options = {}) {
+    return openCsvInNewTab(data, options);
+}
+/**
+ * Копирует CSV в буфер обмена
+ *
+ * @param data - Данные для копирования
+ * @param options - Опции для jsonToCsv
+ * @returns Promise с результатом копирования
+ */
+async function copyCsvToClipboard(data, options = {}) {
+    if (typeof window === 'undefined' || !navigator.clipboard) {
+        throw new ValidationError('copyCsvToClipboard() требует поддержки Clipboard API');
+    }
+    const csv = jsonToCsv$1(data, options);
+    try {
+        await navigator.clipboard.writeText(csv);
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to copy to clipboard:', error);
+        return false;
+    }
+}
+/**
+ * Сохраняет CSV в localStorage
+ *
+ * @param key - Ключ для сохранения
+ * @param data - Данные для сохранения
+ * @param options - Опции для jsonToCsv
+ */
+function saveCsvToLocalStorage(key, data, options = {}) {
+    if (typeof window === 'undefined' || !localStorage) {
+        throw new ValidationError('saveCsvToLocalStorage() требует localStorage');
+    }
+    const csv = jsonToCsv$1(data, options);
+    localStorage.setItem(key, csv);
+}
+/**
+ * Загружает CSV из localStorage
+ *
+ * @param key - Ключ для загрузки
+ * @param options - Опции для csvToJson
+ * @returns Распарсенные данные или null
+ */
+function loadCsvFromLocalStorage(key, options = {}) {
+    if (typeof window === 'undefined' || !localStorage) {
+        throw new ValidationError('loadCsvFromLocalStorage() требует localStorage');
+    }
+    const csv = localStorage.getItem(key);
+    if (!csv) {
+        return null;
+    }
+    return csvToJson$1(csv, options);
+}
+/**
+ * Асинхронная версия loadCsvFromLocalStorage
+ */
+async function loadCsvFromLocalStorageAsync(key, options = {}) {
+    return loadCsvFromLocalStorage(key, options);
+}
+/**
+ * Создает CSV файл из JSON данных (альтернатива downloadAsCsv)
+ * Возвращает Blob вместо автоматического скачивания
+ *
+ * @param data - Массив объектов
+ * @param options - Опции для jsonToCsv
+ * @returns CSV Blob
+ */
+function createCsvBlob(data, options = {}) {
+    const csv = jsonToCsv$1(data, options);
+    return new Blob([csv], {
+        type: 'text/csv;charset=utf-8;'
+    });
+}
+/**
+ * Асинхронная версия createCsvBlob
+ */
+async function createCsvBlobAsync(data, options = {}) {
+    return createCsvBlob(data, options);
+}
+/**
+ * Парсит CSV строку из Blob
+ *
+ * @param blob - CSV Blob
+ * @param options - Опции для csvToJson
+ * @returns Promise с JSON данными
+ */
+async function parseCsvBlob(blob, options = {}) {
+    if (!(blob instanceof Blob)) {
+        throw new ValidationError('Input must be a Blob object');
+    }
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = function (event) {
+            try {
+                const csvText = event.target?.result;
+                const json = csvToJson$1(csvText, options);
+                resolve(json);
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        reader.onerror = function () {
+            reject(new ValidationError('Ошибка чтения Blob'));
+        };
+        reader.readAsText(blob, 'UTF-8');
+    });
+}
+/**
+ * Асинхронная версия parseCsvBlob
+ */
+async function parseCsvBlobAsync(blob, options = {}) {
+    return parseCsvBlob(blob, options);
+}
+// Экспорт для Node.js совместимости
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        downloadAsCsv,
+        downloadAsCsvAsync: downloadAsCsvAsync$1,
+        parseCsvFile,
+        parseCsvFileStream,
+        createCsvBlob,
+        createCsvBlobAsync,
+        parseCsvBlob,
+        parseCsvBlobAsync,
+        jsonToCsvStream,
+        jsonToNdjsonStream,
+        csvToJsonStream,
+        loadCsvFromUrl,
+        loadCsvFromUrlAsync,
+        openCsvInNewTab,
+        openCsvInNewTabAsync,
+        copyCsvToClipboard,
+        saveCsvToLocalStorage,
+        loadCsvFromLocalStorage,
+        loadCsvFromLocalStorageAsync
+    };
+}
+
+// Ядро jtcsv - только базовые функции JSON<->CSV
+// Минимальный размер, максимальная производительность
+const { jsonToCsv, preprocessData, deepUnwrap } = jsonToCsvBrowser;
+const { csvToJson, csvToJsonIterator, autoDetectDelimiter } = csvToJsonBrowser;
+/**
+ * Асинхронная версия jsonToCsv
+ */
+async function jsonToCsvAsync(data, options = {}) {
+    return jsonToCsv(data, options);
+}
+/**
+ * Асинхронная версия csvToJson
+ */
+async function csvToJsonAsync(csv, options = {}) {
+    return csvToJson(csv, options);
+}
+/**
+ * Асинхронная версия parseCsvFile
+ */
+async function parseCsvFileAsync(file, options = {}) {
+    return parseCsvFile(file, options);
+}
+/**
+ * Асинхронная версия autoDetectDelimiter
+ */
+async function autoDetectDelimiterAsync(csv) {
+    return autoDetectDelimiter(csv);
+}
+/**
+ * Асинхронная версия downloadAsCsv
+ */
+async function downloadAsCsvAsync(data, filename = 'export.csv', options = {}) {
+    return downloadAsCsv(data, filename, options);
+}
+// Основной экспорт ядра
+const jtcsvCore = {
+    // JSON to CSV функции
+    jsonToCsv,
+    preprocessData,
+    downloadAsCsv,
+    deepUnwrap,
+    // CSV to JSON функции
+    csvToJson,
+    csvToJsonIterator,
+    parseCsvFile,
+    parseCsvFileStream,
+    jsonToCsvStream,
+    jsonToNdjsonStream,
+    csvToJsonStream,
+    autoDetectDelimiter,
+    // Асинхронные функции
+    jsonToCsvAsync,
+    csvToJsonAsync,
+    parseCsvFileAsync,
+    autoDetectDelimiterAsync,
+    downloadAsCsvAsync,
+    // Error classes
+    ValidationError,
+    SecurityError,
+    FileSystemError,
+    ParsingError,
+    LimitError,
+    ConfigurationError,
+    ERROR_CODES,
+    // Удобные алиасы
+    parse: csvToJson,
+    unparse: jsonToCsv,
+    parseAsync: csvToJsonAsync,
+    unparseAsync: jsonToCsvAsync,
+    // Версия
+    version: '3.0.0-core'
+};
+// Экспорт для разных сред
+if (typeof module !== 'undefined' && module.exports) {
+    // Node.js CommonJS
+    module.exports = jtcsvCore;
+}
+else if (typeof define === 'function' && define.amd) {
+    // AMD
+    define([], () => jtcsvCore);
+}
+else if (typeof window !== 'undefined') {
+    // Браузер (глобальная переменная)
+    window.jtcsv = jtcsvCore;
+}
+
+exports.ConfigurationError = ConfigurationError;
+exports.ERROR_CODES = ERROR_CODES;
+exports.FileSystemError = FileSystemError;
+exports.LimitError = LimitError;
+exports.ParsingError = ParsingError;
+exports.SecurityError = SecurityError;
+exports.ValidationError = ValidationError;
+exports.autoDetectDelimiter = autoDetectDelimiter;
+exports.autoDetectDelimiterAsync = autoDetectDelimiterAsync;
+exports.csvToJson = csvToJson;
+exports.csvToJsonAsync = csvToJsonAsync;
+exports.csvToJsonIterator = csvToJsonIterator;
+exports.csvToJsonStream = csvToJsonStream;
+exports.deepUnwrap = deepUnwrap;
+exports.default = jtcsvCore;
+exports.downloadAsCsv = downloadAsCsv;
+exports.downloadAsCsvAsync = downloadAsCsvAsync;
+exports.jsonToCsv = jsonToCsv;
+exports.jsonToCsvAsync = jsonToCsvAsync;
+exports.jsonToCsvStream = jsonToCsvStream;
+exports.jsonToNdjsonStream = jsonToNdjsonStream;
+exports.parseCsvFile = parseCsvFile;
+exports.parseCsvFileAsync = parseCsvFileAsync;
+exports.parseCsvFileStream = parseCsvFileStream;
+exports.preprocessData = preprocessData;
+//# sourceMappingURL=jtcsv-core.cjs.js.map