jtcsv 2.2.7 → 3.0.0

package/dist/jtcsv-core.umd.js

@@ -0,0 +1,1413 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jtcsv = {}));
+})(this, (function (exports) { 'use strict';
+
+    // Система ошибок для браузерной версии jtcsv
+    // Адаптирована для работы без Node.js специфичных API
+    /**
+     * Базовый класс ошибки jtcsv
+     */
+    class JTCSVError extends Error {
+        constructor(message, code = 'JTCSV_ERROR', details = {}) {
+            super(message);
+            this.name = 'JTCSVError';
+            this.code = code;
+            this.details = details;
+            // Сохранение stack trace
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, JTCSVError);
+            }
+        }
+    }
+    /**
+     * Ошибка валидации
+     */
+    class ValidationError extends JTCSVError {
+        constructor(message, details = {}) {
+            super(message, 'VALIDATION_ERROR', details);
+            this.name = 'ValidationError';
+        }
+    }
+    /**
+     * Ошибка безопасности
+     */
+    class SecurityError extends JTCSVError {
+        constructor(message, details = {}) {
+            super(message, 'SECURITY_ERROR', details);
+            this.name = 'SecurityError';
+        }
+    }
+    /**
+     * Ошибка файловой системы (адаптирована для браузера)
+     */
+    class FileSystemError extends JTCSVError {
+        constructor(message, originalError, 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 (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');
+        }
+        return true;
+    }
+    /**
+     * Экранирование CSV значений для предотвращения инъекций
+     * @private
+     */
+    function escapeCsvValue(value, preventInjection = true) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        const str = String(value);
+        // Экранирование формул для предотвращения CSV инъекций
+        if (preventInjection && /^[=+\-@]/.test(str)) {
+            return "'" + str;
+        }
+        // Экранирование кавычек и переносов строк
+        if (str.includes('"') || str.includes('\n') || str.includes('\r') || str.includes(',')) {
+            return '"' + str.replace(/"/g, '""') + '"';
+        }
+        return str;
+    }
+    /**
+     * Извлечение всех уникальных ключей из массива объектов
+     * @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 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];
+                    return escapeCsvValue(value, 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;
+        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];
+                    return escapeCsvValue(value, 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');
+        }
+        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;
+    }
+    /**
+     * Парсинг 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 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);
+            }
+            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 maxRows = options.maxRows || Infinity;
+        const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
+        // Возврат данных по одной строке
+        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;
+                }
+            }
+            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
+    });
+
+    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';
+    }
+    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;
+        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 && /^[=+\-@]/.test(escaped) ? `'${escaped}` : escaped;
+                    }).join(delimiter);
+                    yield headerLine + '\n';
+                }
+                isFirstChunk = false;
+            }
+            const row = headers.map(header => {
+                const value = item[header];
+                const strValue = value === null || value === undefined ? '' : String(value);
+                if (strValue.includes('"') || strValue.includes('\n') || strValue.includes('\r') || strValue.includes(delimiter)) {
+                    return `"${strValue.replace(/"/g, '""')}"`;
+                }
+                if (preventInjection && /^[=+\-@]/.test(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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=jtcsv-core.umd.js.map