jtcsv 2.2.8 → 3.1.0

package/dist/stream-csv-to-json.js

@@ -0,0 +1,665 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCsvToJsonStream = createCsvToJsonStream;
+exports.createJsonCollectorStream = createJsonCollectorStream;
+exports.streamCsvToJson = streamCsvToJson;
+exports.streamCsvToJsonAsync = streamCsvToJsonAsync;
+exports.createCsvFileToJsonStream = createCsvFileToJsonStream;
+const errors_1 = require("./errors");
+const stream_1 = require("stream");
+const promises_1 = require("stream/promises");
+const schema_validator_1 = require("./src/utils/schema-validator");
+const bom_utils_1 = require("./src/utils/bom-utils");
+function createCsvToJsonStream(options = {}) {
+    return (0, errors_1.safeExecuteSync)(() => {
+        const { delimiter, autoDetect = true, candidates = [';', ',', '\t', '|'], hasHeaders = true, renameMap = {}, trim = true, parseNumbers = false, parseBooleans = false, maxRows = Infinity, transform: customTransform, schema, useFastPath = true, fastPathMode = 'objects', onError = 'throw', errorHandler, repairRowShifts = true, normalizeQuotes = true } = options;
+        if (delimiter !== undefined && typeof delimiter !== 'string') {
+            throw new errors_1.ConfigurationError('Delimiter must be a string');
+        }
+        if (delimiter && delimiter.length !== 1) {
+            throw new errors_1.ConfigurationError('Delimiter must be a single character');
+        }
+        if (typeof hasHeaders !== 'boolean') {
+            throw new errors_1.ConfigurationError('hasHeaders must be a boolean');
+        }
+        if (renameMap && typeof renameMap !== 'object') {
+            throw new errors_1.ConfigurationError('renameMap must be an object');
+        }
+        if (maxRows !== Infinity && (typeof maxRows !== 'number' || maxRows <= 0)) {
+            throw new errors_1.ConfigurationError('maxRows must be a positive number or Infinity');
+        }
+        if (customTransform !== undefined && typeof customTransform !== 'function') {
+            throw new errors_1.ConfigurationError('transform must be a function');
+        }
+        if (schema && typeof schema !== 'object') {
+            throw new errors_1.ConfigurationError('schema must be an object');
+        }
+        if (onError !== undefined && !['skip', 'warn', 'throw'].includes(onError)) {
+            throw new errors_1.ConfigurationError('onError must be "skip", "warn", or "throw"');
+        }
+        if (errorHandler !== undefined && typeof errorHandler !== 'function') {
+            throw new errors_1.ConfigurationError('errorHandler must be a function');
+        }
+        const schemaValidators = schema ? (0, schema_validator_1.createSchemaValidators)(schema) : null;
+        let buffer = '';
+        let headers = [];
+        let finalHeaders = [];
+        let headersProcessed = false;
+        let rowCount = 0;
+        let inputLineNumber = 0;
+        let finalDelimiter = delimiter;
+        let pendingRow = null;
+        let pendingRowLineNumber = null;
+        let pendingRowLine = null;
+        const normalizeValue = (value) => {
+            let normalized = value;
+            if (trim && typeof normalized === 'string') {
+                normalized = normalized.trim();
+            }
+            if (typeof normalized === 'string') {
+                if (normalized === '') {
+                    return null;
+                }
+                if (normalized[0] === "'" && normalized.length > 1) {
+                    const candidate = normalized.slice(1);
+                    const leading = trim ? candidate.trimStart() : candidate;
+                    const firstChar = leading[0];
+                    if (firstChar === '=' || firstChar === '+' || firstChar === '-' || firstChar === '@') {
+                        normalized = candidate;
+                    }
+                }
+            }
+            if (parseNumbers && typeof normalized === 'string' && normalized.trim() !== '' && !isNaN(Number(normalized))) {
+                normalized = Number(normalized);
+            }
+            if (parseBooleans && normalized !== null && normalized !== undefined) {
+                const lowerValue = String(normalized).toLowerCase();
+                if (lowerValue === 'true' || lowerValue === 'false') {
+                    normalized = lowerValue === 'true';
+                }
+            }
+            return normalized;
+        };
+        const isEmptyValue = (value) => value === undefined || value === null || value === '';
+        const 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;
+        };
+        const hasAnyQuotes = (value) => typeof value === 'string' && value.includes('"');
+        const normalizeQuotesInField = (value) => {
+            if (typeof value !== 'string') {
+                return value;
+            }
+            if ((value.startsWith('{') && value.endsWith('}')) ||
+                (value.startsWith('[') && value.endsWith(']'))) {
+                return value;
+            }
+            let normalized = value.replace(/"{2,}/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;
+        };
+        const normalizePhoneValue = (value) => {
+            if (typeof value !== 'string') {
+                return value;
+            }
+            const trimmed = value.trim();
+            if (trimmed === '') {
+                return trimmed;
+            }
+            return trimmed.replace(/["'\\]/g, '');
+        };
+        const normalizeRowQuotes = (row, headersList) => {
+            const normalized = {};
+            const phoneKeys = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+            for (const header of headersList) {
+                const baseValue = normalizeQuotesInField(row[header]);
+                if (phoneKeys.has(String(header).toLowerCase())) {
+                    normalized[header] = normalizePhoneValue(baseValue);
+                }
+                else {
+                    normalized[header] = baseValue;
+                }
+            }
+            return normalized;
+        };
+        const looksLikeUserAgent = (value) => {
+            if (typeof value !== 'string') {
+                return false;
+            }
+            return /Mozilla\/|Opera\/|MSIE|AppleWebKit|Gecko|Safari|Chrome\//.test(value);
+        };
+        const isHexColor = (value) => typeof value === 'string' && /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
+        const attemptMergeRows = (row, nextRow) => {
+            const headerCount = finalHeaders.length;
+            if (headerCount === 0) {
+                return null;
+            }
+            const values = finalHeaders.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) {
+                const nextValues = finalHeaders.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 merged = {};
+                    for (let i = 0; i < headerCount; i++) {
+                        merged[finalHeaders[i]] = values[i];
+                    }
+                    return merged;
+                }
+            }
+            if (headerCount >= 6) {
+                const nextValues = finalHeaders.map((header) => nextRow[header]);
+                const nextHex = nextValues[4];
+                const nextUserAgentHead = nextValues[2];
+                const nextUserAgentTail = nextValues[3];
+                const shouldMergeUserAgent = isEmptyValue(values[4])
+                    && isEmptyValue(values[5])
+                    && isHexColor(nextHex)
+                    && (looksLikeUserAgent(nextUserAgentHead) || looksLikeUserAgent(nextUserAgentTail));
+                if (shouldMergeUserAgent) {
+                    const addressParts = [values[3], nextValues[0], nextValues[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 merged = {};
+                    for (let i = 0; i < headerCount; i++) {
+                        merged[finalHeaders[i]] = values[i];
+                    }
+                    return merged;
+                }
+            }
+            return null;
+        };
+        const finalizeHeaders = (nextHeaders) => {
+            headers = nextHeaders;
+            finalHeaders = headers.map((header) => renameMap[header] || header);
+            headersProcessed = true;
+        };
+        const emitRow = (row, line, lineNumber, stream) => {
+            if (maxRows !== Infinity && rowCount >= maxRows) {
+                throw new errors_1.LimitError(`CSV size exceeds maximum limit of ${maxRows} rows`, maxRows, rowCount + 1);
+            }
+            let outputRow = row;
+            if (normalizeQuotes) {
+                outputRow = normalizeRowQuotes(outputRow, finalHeaders);
+            }
+            if (schemaValidators && Object.keys(schemaValidators).length > 0) {
+                for (const [field, validator] of Object.entries(schemaValidators)) {
+                    const typedValidator = validator;
+                    const value = outputRow[field];
+                    if (typeof typedValidator.validate === 'function' && !typedValidator.validate(value)) {
+                        throw new errors_1.ValidationError(`Invalid value for field "${field}"`);
+                    }
+                    if (typeof typedValidator.format === 'function') {
+                        outputRow[field] = typedValidator.format(value);
+                    }
+                }
+            }
+            if (customTransform) {
+                let transformed;
+                try {
+                    transformed = customTransform(outputRow);
+                }
+                catch (error) {
+                    throw new errors_1.ValidationError(`Transform function error: ${error.message}`);
+                }
+                if (!transformed || typeof transformed !== 'object') {
+                    throw new errors_1.ValidationError('Transform function must return an object');
+                }
+                stream.push(transformed);
+            }
+            else {
+                stream.push(outputRow);
+            }
+            rowCount++;
+        };
+        const handleRowError = (error, line, lineNumber) => {
+            if (error instanceof errors_1.LimitError) {
+                throw error;
+            }
+            if (errorHandler) {
+                errorHandler(error, line, lineNumber);
+            }
+            if (onError === 'warn') {
+                if (process.env['NODE_ENV'] !== 'test') {
+                    console.warn(`[jtcsv] Line ${lineNumber}: ${error.message}`);
+                }
+                return true;
+            }
+            if (onError === 'skip') {
+                return true;
+            }
+            throw error;
+        };
+        const transformStream = new stream_1.Transform({
+            readableObjectMode: true,
+            writableObjectMode: false,
+            transform(chunk, encoding, callback) {
+                try {
+                    const chunkStr = chunk.toString();
+                    buffer += chunkStr;
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    let errorLine = '';
+                    let errorLineNumber = 0;
+                    for (const line of lines) {
+                        if (line.trim() === '') {
+                            continue;
+                        }
+                        inputLineNumber += 1;
+                        errorLine = line;
+                        errorLineNumber = inputLineNumber;
+                        if (rowCount >= maxRows) {
+                            throw new errors_1.LimitError(`CSV size exceeds maximum limit of ${maxRows} rows`, maxRows, rowCount + 1);
+                        }
+                        try {
+                            if (!finalDelimiter && autoDetect && !headersProcessed) {
+                                finalDelimiter = autoDetectDelimiterFromLine(line, candidates);
+                            }
+                            if (!finalDelimiter) {
+                                finalDelimiter = ';';
+                            }
+                            const values = parseCsvLine(line, finalDelimiter, trim, inputLineNumber);
+                            if (!headersProcessed) {
+                                if (hasHeaders) {
+                                    finalizeHeaders(values);
+                                    continue;
+                                }
+                                else {
+                                    finalizeHeaders(values.map((_, index) => `column${index + 1}`));
+                                }
+                            }
+                            if (finalHeaders.length === 0) {
+                                finalHeaders = headers.map((header) => renameMap[header] || header);
+                            }
+                            if (values.length !== finalHeaders.length) {
+                                throw errors_1.ParsingError.fieldCountMismatch(finalHeaders.length, values.length, inputLineNumber, line);
+                            }
+                            const row = {};
+                            for (let j = 0; j < finalHeaders.length; j++) {
+                                const value = normalizeValue(values[j]);
+                                row[finalHeaders[j]] = value;
+                            }
+                            if (repairRowShifts) {
+                                if (!pendingRow) {
+                                    pendingRow = row;
+                                    pendingRowLineNumber = inputLineNumber;
+                                    pendingRowLine = line;
+                                    continue;
+                                }
+                                const merged = attemptMergeRows(pendingRow, row);
+                                if (merged) {
+                                    const baseLine = pendingRowLine ?? line;
+                                    const baseLineNumber = pendingRowLineNumber ?? inputLineNumber;
+                                    pendingRow = null;
+                                    pendingRowLine = null;
+                                    pendingRowLineNumber = null;
+                                    errorLine = baseLine;
+                                    errorLineNumber = baseLineNumber;
+                                    emitRow(merged, baseLine, baseLineNumber, this);
+                                }
+                                else {
+                                    const baseLine = pendingRowLine ?? line;
+                                    const baseLineNumber = pendingRowLineNumber ?? inputLineNumber;
+                                    const rowToEmit = pendingRow;
+                                    pendingRow = row;
+                                    pendingRowLine = line;
+                                    pendingRowLineNumber = inputLineNumber;
+                                    errorLine = baseLine;
+                                    errorLineNumber = baseLineNumber;
+                                    emitRow(rowToEmit, baseLine, baseLineNumber, this);
+                                }
+                            }
+                            else {
+                                emitRow(row, line, inputLineNumber, this);
+                            }
+                        }
+                        catch (error) {
+                            if (!headersProcessed && hasHeaders) {
+                                throw error;
+                            }
+                            if (handleRowError(error, errorLine, errorLineNumber)) {
+                                continue;
+                            }
+                        }
+                    }
+                    callback();
+                }
+                catch (error) {
+                    callback(error);
+                }
+            },
+            flush(callback) {
+                if (buffer.trim() !== '') {
+                    let errorLine = buffer;
+                    let errorLineNumber = inputLineNumber;
+                    try {
+                        if (rowCount >= maxRows) {
+                            throw new errors_1.LimitError(`CSV size exceeds maximum limit of ${maxRows} rows`, maxRows, rowCount + 1);
+                        }
+                        if (rowCount < maxRows) {
+                            inputLineNumber += 1;
+                            errorLineNumber = inputLineNumber;
+                            if (!finalDelimiter && autoDetect && !headersProcessed) {
+                                finalDelimiter = autoDetectDelimiterFromLine(buffer, candidates);
+                            }
+                            if (!finalDelimiter) {
+                                finalDelimiter = ';';
+                            }
+                            const values = parseCsvLine(buffer, finalDelimiter, trim, inputLineNumber);
+                            if (!headersProcessed) {
+                                if (hasHeaders) {
+                                    finalizeHeaders(values);
+                                }
+                                else {
+                                    finalizeHeaders(values.map((_, index) => `column${index + 1}`));
+                                }
+                            }
+                            else {
+                                if (finalHeaders.length === 0) {
+                                    finalHeaders = headers.map((header) => renameMap[header] || header);
+                                }
+                                if (values.length !== finalHeaders.length) {
+                                    throw errors_1.ParsingError.fieldCountMismatch(finalHeaders.length, values.length, inputLineNumber, buffer);
+                                }
+                                const row = {};
+                                for (let j = 0; j < finalHeaders.length; j++) {
+                                    const value = normalizeValue(values[j]);
+                                    row[finalHeaders[j]] = value;
+                                }
+                                if (repairRowShifts) {
+                                    if (!pendingRow) {
+                                        pendingRow = row;
+                                        pendingRowLineNumber = inputLineNumber;
+                                        pendingRowLine = buffer;
+                                    }
+                                    else {
+                                        const merged = attemptMergeRows(pendingRow, row);
+                                        if (merged) {
+                                            const baseLine = pendingRowLine ?? buffer;
+                                            const baseLineNumber = pendingRowLineNumber ?? inputLineNumber;
+                                            pendingRow = null;
+                                            pendingRowLine = null;
+                                            pendingRowLineNumber = null;
+                                            errorLine = baseLine;
+                                            errorLineNumber = baseLineNumber;
+                                            emitRow(merged, baseLine, baseLineNumber, this);
+                                        }
+                                        else {
+                                            const baseLine = pendingRowLine ?? buffer;
+                                            const baseLineNumber = pendingRowLineNumber ?? inputLineNumber;
+                                            const rowToEmit = pendingRow;
+                                            pendingRow = row;
+                                            pendingRowLine = buffer;
+                                            pendingRowLineNumber = inputLineNumber;
+                                            errorLine = baseLine;
+                                            errorLineNumber = baseLineNumber;
+                                            emitRow(rowToEmit, baseLine, baseLineNumber, this);
+                                        }
+                                    }
+                                }
+                                else {
+                                    emitRow(row, buffer, inputLineNumber, this);
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        if (!headersProcessed && hasHeaders) {
+                            callback(error);
+                            return;
+                        }
+                        try {
+                            if (handleRowError(error, errorLine, errorLineNumber)) {
+                                callback();
+                                return;
+                            }
+                        }
+                        catch (handledError) {
+                            callback(handledError);
+                            return;
+                        }
+                    }
+                }
+                if (pendingRow) {
+                    const baseLine = pendingRowLine ?? '';
+                    const baseLineNumber = pendingRowLineNumber ?? inputLineNumber;
+                    try {
+                        emitRow(pendingRow, baseLine, baseLineNumber, this);
+                    }
+                    catch (error) {
+                        try {
+                            if (handleRowError(error, baseLine, baseLineNumber)) {
+                                callback();
+                                return;
+                            }
+                        }
+                        catch (handledError) {
+                            callback(handledError);
+                            return;
+                        }
+                    }
+                    pendingRow = null;
+                    pendingRowLine = null;
+                    pendingRowLineNumber = null;
+                }
+                callback();
+            }
+        });
+        return transformStream;
+    }, 'STREAM_CREATION_ERROR', { function: 'createCsvToJsonStream' });
+}
+function createJsonCollectorStream(options = {}) {
+    return (0, errors_1.safeExecuteSync)(() => {
+        const collectedData = [];
+        const transformStream = new stream_1.Transform({
+            writableObjectMode: true,
+            readableObjectMode: false,
+            transform(chunk, encoding, callback) {
+                collectedData.push(chunk);
+                transformStream._collectedData = collectedData;
+                callback();
+            },
+            flush(callback) {
+                this.push(JSON.stringify(collectedData, null, 2));
+                transformStream._collectedData = collectedData;
+                callback();
+            }
+        });
+        transformStream._collectedData = collectedData;
+        if (Object.keys(options).length > 0) {
+            const csvToJsonStream = createCsvToJsonStream(options);
+            csvToJsonStream.pipe(transformStream);
+            return csvToJsonStream;
+        }
+        return transformStream;
+    }, 'STREAM_CREATION_ERROR', { function: 'createJsonCollectorStream' });
+}
+async function streamCsvToJson(csvOrStream, outputOrOptions = {}, options = {}) {
+    return (0, errors_1.safeExecuteAsync)(async () => {
+        const isReadableStream = (value) => value instanceof stream_1.Readable || (value && typeof value.pipe === 'function');
+        const isWritableStream = (value) => value instanceof stream_1.Writable || (value && typeof value.write === 'function');
+        if (isReadableStream(csvOrStream) && isWritableStream(outputOrOptions)) {
+            const csvToJsonStream = createCsvToJsonStream(options);
+            await (0, promises_1.pipeline)(csvOrStream, csvToJsonStream, outputOrOptions);
+            return;
+        }
+        const streamOptions = outputOrOptions || {};
+        const readableStream = new stream_1.Readable({
+            read() {
+                this.push(csvOrStream);
+                this.push(null);
+            }
+        });
+        const csvToJsonStream = createCsvToJsonStream(streamOptions);
+        const collectorStream = createJsonCollectorStream();
+        await (0, promises_1.pipeline)(readableStream, csvToJsonStream, collectorStream);
+        return collectorStream._collectedData || [];
+    }, 'STREAM_PROCESSING_ERROR', { function: 'streamCsvToJson' });
+}
+async function streamCsvToJsonAsync(csv, options = {}) {
+    return (0, errors_1.safeExecuteAsync)(async () => {
+        const { useWorkers = false, workerCount, chunkSize, onProgress, ...streamOptions } = options;
+        return streamCsvToJson(csv, streamOptions);
+    }, 'STREAM_PROCESSING_ERROR', { function: 'streamCsvToJsonAsync' });
+}
+async function createCsvFileToJsonStream(filePath, options = {}) {
+    return (0, errors_1.safeExecuteAsync)(async () => {
+        const { validatePath = true, ...streamOptions } = options;
+        const fs = require('fs');
+        const path = require('path');
+        let safePath = filePath;
+        if (validatePath) {
+            if (typeof filePath !== 'string' || filePath.trim().length === 0) {
+                throw new errors_1.ValidationError('File path must be a non-empty string');
+            }
+            const normalized = path.normalize(filePath.trim());
+            const traversalPattern = /(^|[\\/])\.\.([\\/]|$)/;
+            if (traversalPattern.test(normalized)) {
+                throw new errors_1.SecurityError('Directory traversal detected in file path');
+            }
+            if (path.extname(normalized).toLowerCase() !== '.csv') {
+                throw new errors_1.ValidationError('File must have .csv extension');
+            }
+            safePath = normalized;
+        }
+        try {
+            await fs.promises.access(safePath);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                throw new errors_1.FileSystemError(`File not found: ${safePath}`, error);
+            }
+            throw error;
+        }
+        const fileStream = fs.createReadStream(safePath, 'utf8');
+        const csvToJsonStream = createCsvToJsonStream(streamOptions);
+        const bomStripStream = (0, bom_utils_1.createBomStripStream)();
+        const { pipeline } = require('stream');
+        const { PassThrough } = require('stream');
+        const outputStream = new PassThrough({ objectMode: true });
+        pipeline(fileStream, bomStripStream, csvToJsonStream, outputStream, (error) => {
+            if (error) {
+                outputStream.emit('error', error);
+            }
+        });
+        return outputStream;
+    }, 'STREAM_CREATION_ERROR', { function: 'createCsvFileToJsonStream' });
+}
+function autoDetectDelimiterFromLine(line, candidates) {
+    let bestDelimiter = candidates[0];
+    let bestScore = -1;
+    for (const delimiter of candidates) {
+        let score = 0;
+        for (let i = 0; i < line.length; i++) {
+            if (line[i] === delimiter) {
+                score++;
+            }
+        }
+        const fields = line.split(delimiter);
+        let hasQuotes = false;
+        let consistent = true;
+        for (const field of fields) {
+            if (field.includes('"') || field.includes("'")) {
+                hasQuotes = true;
+            }
+        }
+        if (!hasQuotes && fields.length > 1) {
+            score += 10;
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            bestDelimiter = delimiter;
+        }
+    }
+    return bestDelimiter;
+}
+function parseCsvLine(line, delimiter, trim, lineNumber) {
+    const result = [];
+    let currentField = '';
+    let inQuotes = false;
+    let quoteChar = '"';
+    let escapeNext = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        const nextChar = i < line.length - 1 ? line[i + 1] : '';
+        if (escapeNext) {
+            currentField += char;
+            escapeNext = false;
+            continue;
+        }
+        if (char === '\\') {
+            escapeNext = true;
+            continue;
+        }
+        if (!inQuotes && char === delimiter) {
+            result.push(trim ? currentField.trim() : currentField);
+            currentField = '';
+        }
+        else if (!inQuotes && (char === '"' || char === "'")) {
+            inQuotes = true;
+            quoteChar = char;
+        }
+        else if (inQuotes && char === quoteChar && nextChar === quoteChar) {
+            currentField += char;
+            if (i + 2 === line.length) {
+                inQuotes = false;
+            }
+            i++;
+        }
+        else if (inQuotes && char === quoteChar) {
+            inQuotes = false;
+        }
+        else {
+            currentField += char;
+        }
+    }
+    if (escapeNext) {
+        currentField += '\\';
+    }
+    result.push(trim ? currentField.trim() : currentField);
+    if (inQuotes) {
+        throw errors_1.ParsingError.unclosedQuotes(lineNumber ?? null, null, line.substring(0, 100));
+    }
+    return result;
+}
+//# sourceMappingURL=stream-csv-to-json.js.map