cisv 0.4.8 → 0.4.10

package/README.md

@@ -83,7 +83,6 @@ Built-in transform names:
 - `trim`
 - `to_int` (or `int`)
 - `to_float` (or `float`)
-- `hash_sha256` (or `sha256`)
 - `base64_encode` (or `base64`)
 
 ## Examples

package/binding.gyp

@@ -21,7 +21,6 @@
       "cflags_cc!": [ "-fno-exceptions" ],
       "cflags_cc": ["-O3"],
       "defines": [
-        "NAPI_DISABLE_CPP_EXCEPTIONS",
         "NAPI_VERSION=6"
       ],
       "conditions": [

package/cisv/cisv_addon.cc

@@ -5,8 +5,11 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <algorithm>
 #include <chrono>
 #include <cstdint>
+#include <climits>
+#include <cmath>
 
 namespace {
 
@@ -46,6 +49,126 @@ static void ValidateSingleCharOption(
     *target = raw[0];
 }
 
+static double MaxJsSafeInteger() {
+    return 9007199254740991.0;
+}
+
+static bool IsWholeNumber(double value) {
+    return std::isfinite(value) && std::floor(value) == value;
+}
+
+static void ApplyBooleanOption(
+    Napi::Env env,
+    const Napi::Object &options,
+    const char *option_name,
+    bool *target
+) {
+    if (!options.Has(option_name)) {
+        return;
+    }
+
+    Napi::Value value = options.Get(option_name);
+    if (!value.IsBoolean()) {
+        throw Napi::TypeError::New(env, std::string(option_name) + " must be a boolean");
+    }
+
+    *target = value.As<Napi::Boolean>();
+}
+
+static void ApplySizeOption(
+    Napi::Env env,
+    const Napi::Object &options,
+    const char *option_name,
+    size_t *target
+) {
+    if (!options.Has(option_name)) {
+        return;
+    }
+
+    Napi::Value value = options.Get(option_name);
+    if (value.IsNull() || value.IsUndefined()) {
+        *target = 0;
+        return;
+    }
+    if (!value.IsNumber()) {
+        throw Napi::TypeError::New(env, std::string(option_name) + " must be a number");
+    }
+
+    double raw = value.As<Napi::Number>().DoubleValue();
+    double max_value = static_cast<double>(SIZE_MAX);
+    if (!IsWholeNumber(raw) || raw < 0.0 || raw > max_value || raw > MaxJsSafeInteger()) {
+        throw Napi::RangeError::New(env, std::string(option_name) + " is out of range");
+    }
+
+    *target = static_cast<size_t>(raw);
+}
+
+static void ApplyLineOption(
+    Napi::Env env,
+    const Napi::Object &options,
+    const char *option_name,
+    int *target
+) {
+    if (!options.Has(option_name)) {
+        return;
+    }
+
+    Napi::Value value = options.Get(option_name);
+    if (value.IsNull() || value.IsUndefined()) {
+        *target = 0;
+        return;
+    }
+    if (!value.IsNumber()) {
+        throw Napi::TypeError::New(env, std::string(option_name) + " must be a number");
+    }
+
+    double raw = value.As<Napi::Number>().DoubleValue();
+    if (!IsWholeNumber(raw) || raw < 0.0 || raw > static_cast<double>(INT_MAX)) {
+        throw Napi::RangeError::New(env, std::string(option_name) + " is out of range");
+    }
+
+    *target = static_cast<int>(raw);
+}
+
+static void ValidateConfigSemantics(Napi::Env env, const cisv_config &config) {
+    if (config.delimiter == config.quote) {
+        throw Napi::TypeError::New(env, "delimiter and quote cannot be the same");
+    }
+    if (config.escape != '\0' && config.escape == config.delimiter) {
+        throw Napi::TypeError::New(env, "escape and delimiter cannot be the same");
+    }
+    if (config.escape != '\0' && config.escape == config.quote) {
+        throw Napi::TypeError::New(env, "escape and quote cannot be the same");
+    }
+    if (config.comment != '\0' &&
+        (config.comment == config.delimiter || config.comment == config.quote || config.comment == config.escape)) {
+        throw Napi::TypeError::New(env, "comment cannot conflict with delimiter, quote, or escape");
+    }
+
+    int effective_from = config.from_line > 0 ? config.from_line : 1;
+    if (config.to_line != 0 && config.to_line < effective_from) {
+        throw Napi::RangeError::New(env, "toLine must be >= fromLine");
+    }
+}
+
+static void ApplyConfigOptions(Napi::Env env, const Napi::Object &options, cisv_config *config) {
+    ValidateSingleCharOption(env, options, "delimiter", &config->delimiter);
+    ValidateSingleCharOption(env, options, "quote", &config->quote);
+    ValidateSingleCharOption(env, options, "escape", &config->escape, true);
+    ValidateSingleCharOption(env, options, "comment", &config->comment, true);
+
+    ApplyBooleanOption(env, options, "skipEmptyLines", &config->skip_empty_lines);
+    ApplyBooleanOption(env, options, "trim", &config->trim);
+    ApplyBooleanOption(env, options, "relaxed", &config->relaxed);
+    ApplyBooleanOption(env, options, "skipLinesWithError", &config->skip_lines_with_error);
+
+    ApplySizeOption(env, options, "maxRowSize", &config->max_row_size);
+    ApplyLineOption(env, options, "fromLine", &config->from_line);
+    ApplyLineOption(env, options, "toLine", &config->to_line);
+
+    ValidateConfigSemantics(env, *config);
+}
+
 // =============================================================================
 // SECURITY: UTF-8 validation to prevent V8 crashes on invalid input
 // Invalid UTF-8 data can cause Napi::String::New to throw or crash
@@ -144,7 +267,7 @@ static napi_value SafeNewStringValue(napi_env env, const char* data, size_t len)
             if (napi_create_string_latin1(env, data, len, &short_value) == napi_ok && short_value) {
                 return short_value;
             }
-        } else {
+        } else if (isValidUtf8(data, len)) {
             if (napi_create_string_utf8(env, data, len, &short_value) == napi_ok && short_value) {
                 return short_value;
             }
@@ -221,6 +344,136 @@ static Napi::String SafeNewString(Napi::Env env, const char* data, size_t len) {
     return Napi::String(env, SafeNewStringValue(env, data, len));
 }
 
+static napi_value NewLatin1StringValue(napi_env env, const char* data, size_t len) {
+    napi_value value = nullptr;
+    if (napi_create_string_latin1(env, data, len, &value) == napi_ok && value) {
+        return value;
+    }
+    napi_create_string_utf8(env, data, len, &value);
+    return value;
+}
+
+static napi_value NewCsvStringValue(
+    napi_env env,
+    const char* data,
+    size_t len,
+    bool ascii_only
+) {
+    return ascii_only ? NewLatin1StringValue(env, data, len) : SafeNewStringValue(env, data, len);
+}
+
+static bool rowsAreAscii(const std::vector<std::vector<std::string>> &rows) {
+    for (const auto &row : rows) {
+        for (const auto &field : row) {
+            if (!isAllAscii(field.data(), field.size())) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+static bool canUseSimpleLfFastPath(const cisv_config &config) {
+    return config.escape == '\0' &&
+        config.comment == '\0' &&
+        !config.trim &&
+        !config.skip_empty_lines &&
+        !config.relaxed &&
+        !config.skip_lines_with_error &&
+        config.max_row_size == 0 &&
+        config.from_line <= 1 &&
+        config.to_line == 0;
+}
+
+static bool tryParseSimpleLfToJsRows(
+    napi_env env,
+    const uint8_t *data,
+    size_t len,
+    const cisv_config &config,
+    napi_value *out
+) {
+    *out = nullptr;
+    if (!data || !canUseSimpleLfFastPath(config)) {
+        return false;
+    }
+    if (len >= 3 && data[0] == 0xEF && data[1] == 0xBB && data[2] == 0xBF) {
+        return false;
+    }
+
+    size_t row_count = 0;
+    bool saw_data_in_row = false;
+    for (size_t i = 0; i < len; i++) {
+        const uint8_t c = data[i];
+        if (c == static_cast<uint8_t>(config.quote) || c == '\r' || (c & 0x80)) {
+            return false;
+        }
+        if (c == '\n') {
+            row_count++;
+            saw_data_in_row = false;
+        } else {
+            saw_data_in_row = true;
+        }
+    }
+    if (saw_data_in_row || (len > 0 && data[len - 1] != '\n')) {
+        row_count++;
+    }
+
+    napi_value rows;
+    if (napi_create_array_with_length(env, row_count, &rows) != napi_ok) {
+        return false;
+    }
+
+    size_t row_idx = 0;
+    size_t line_start = 0;
+    while (line_start < len && row_idx < row_count) {
+        size_t line_end = line_start;
+        while (line_end < len && data[line_end] != '\n') {
+            line_end++;
+        }
+
+        size_t field_count = 1;
+        for (size_t i = line_start; i < line_end; i++) {
+            if (data[i] == static_cast<uint8_t>(config.delimiter)) {
+                field_count++;
+            }
+        }
+
+        napi_value row;
+        if (napi_create_array_with_length(env, field_count, &row) != napi_ok) {
+            return false;
+        }
+
+        size_t field_idx = 0;
+        size_t field_start = line_start;
+        for (size_t i = line_start; i <= line_end; i++) {
+            if (i == line_end || data[i] == static_cast<uint8_t>(config.delimiter)) {
+                napi_value field = NewLatin1StringValue(
+                    env,
+                    reinterpret_cast<const char*>(data + field_start),
+                    i - field_start);
+                if (!field || napi_set_element(env, row, field_idx, field) != napi_ok) {
+                    return false;
+                }
+                field_idx++;
+                field_start = i + 1;
+            }
+        }
+
+        if (napi_set_element(env, rows, row_idx, row) != napi_ok) {
+            return false;
+        }
+        row_idx++;
+
+        if (line_end == len) {
+            break;
+        }
+        line_start = line_end + 1;
+    }
+
+    *out = rows;
+    return true;
+}
+
 // Extended RowCollector that handles transforms
 struct RowCollector {
     std::vector<std::string> current;
@@ -427,11 +680,16 @@ static bool collectParallelRows(
 
 static Napi::Array rowsToJsArray(Napi::Env env, const std::vector<std::vector<std::string>> &rows) {
     Napi::Array out = Napi::Array::New(env, rows.size());
+    const bool ascii_only = rowsAreAscii(rows);
     for (size_t i = 0; i < rows.size(); i++) {
         Napi::Array row = Napi::Array::New(env, rows[i].size());
         for (size_t j = 0; j < rows[i].size(); j++) {
             const std::string &field = rows[i][j];
-            row[j] = SafeNewString(env, field.c_str(), field.length());
+            napi_set_element(
+                env,
+                row,
+                j,
+                NewCsvStringValue(env, field.c_str(), field.length(), ascii_only));
         }
         out[i] = row;
     }
@@ -589,7 +847,7 @@ public:
     }
 
     CisvParser(const Napi::CallbackInfo &info) : Napi::ObjectWrap<CisvParser>(info) {
-        rc_ = new RowCollector();
+        rc_ = nullptr;
         parser_ = nullptr;
         parse_time_ = 0;
         total_bytes_ = 0;
@@ -597,6 +855,8 @@ public:
         iterator_ = nullptr;
         batch_result_ = nullptr;
         stream_buffering_active_ = true;
+        pending_buffer_data_ = nullptr;
+        pending_buffer_size_ = 0;
 
         // Initialize configuration with defaults
         cisv_config_init(&config_);
@@ -609,6 +869,8 @@ public:
             ApplyConfigFromObject(options);
         }
 
+        rc_ = new RowCollector();
+
         // Set callbacks
         config_.field_cb = field_cb;
         config_.row_cb = row_cb;
@@ -623,51 +885,9 @@ public:
     // Apply configuration from JavaScript object
     void ApplyConfigFromObject(Napi::Object options) {
         Napi::Env env = options.Env();
-
-        // Delimiter
-        ValidateSingleCharOption(env, options, "delimiter", &config_.delimiter);
-
-        // Quote character
-        ValidateSingleCharOption(env, options, "quote", &config_.quote);
-
-        // Escape character
-        ValidateSingleCharOption(env, options, "escape", &config_.escape, true);
-
-        // Comment character
-        ValidateSingleCharOption(env, options, "comment", &config_.comment, true);
-
-        // Boolean options
-        if (options.Has("skipEmptyLines")) {
-            config_.skip_empty_lines = options.Get("skipEmptyLines").As<Napi::Boolean>();
-        }
-
-        if (options.Has("trim")) {
-            config_.trim = options.Get("trim").As<Napi::Boolean>();
-        }
-
-        if (options.Has("relaxed")) {
-            config_.relaxed = options.Get("relaxed").As<Napi::Boolean>();
-        }
-
-        if (options.Has("skipLinesWithError")) {
-            config_.skip_lines_with_error = options.Get("skipLinesWithError").As<Napi::Boolean>();
-        }
-
-        // Numeric options
-        if (options.Has("maxRowSize")) {
-            Napi::Value val = options.Get("maxRowSize");
-            if (!val.IsNull() && !val.IsUndefined()) {
-                config_.max_row_size = val.As<Napi::Number>().Uint32Value();
-            }
-        }
-
-        if (options.Has("fromLine")) {
-            config_.from_line = options.Get("fromLine").As<Napi::Number>().Int32Value();
-        }
-
-        if (options.Has("toLine")) {
-            config_.to_line = options.Get("toLine").As<Napi::Number>().Int32Value();
-        }
+        cisv_config next = config_;
+        ApplyConfigOptions(env, options, &next);
+        config_ = next;
     }
 
     // Set configuration after creation
@@ -751,6 +971,9 @@ public:
                 rc_ = nullptr;
             }
             clearBatchResult();
+            clearFastRows();
+            pending_stream_.clear();
+            clearPendingBuffer();
             is_destroyed_ = true;
         }
     }
@@ -817,16 +1040,28 @@ public:
             throw Napi::Error::New(env, "Parser has been destroyed");
         }
 
-        if (info.Length() != 1 || !info[0].IsString()) {
-            throw Napi::TypeError::New(env, "Expected CSV string");
+        if (info.Length() != 1 || (!info[0].IsString() && !info[0].IsBuffer())) {
+            throw Napi::TypeError::New(env, "Expected CSV string or Buffer");
         }
 
-        std::string content = info[0].As<Napi::String>();
+        const char *content_data = nullptr;
+        size_t content_len = 0;
+        std::string content_storage;
+
+        if (info[0].IsBuffer()) {
+            auto buffer = info[0].As<Napi::Buffer<char>>();
+            content_data = buffer.Data();
+            content_len = buffer.Length();
+        } else {
+            content_storage = info[0].As<Napi::String>();
+            content_data = content_storage.data();
+            content_len = content_storage.size();
+        }
 
         resetRowState();
 
         if (!hasTransforms()) {
-            cisv_result_t *batch = cisv_parse_string_batch(content.c_str(), content.length(), &config_);
+            cisv_result_t *batch = cisv_parse_string_batch(content_data, content_len, &config_);
             if (!batch) {
                 throw Napi::Error::New(env, "parse error: " + std::string(strerror(errno)));
             }
@@ -843,14 +1078,14 @@ public:
             ensureParser(env);
 
             // Write the string content as chunks
-            cisv_parser_write(parser_, (const uint8_t*)content.c_str(), content.length());
+            cisv_parser_write(parser_, reinterpret_cast<const uint8_t*>(content_data), content_len);
             cisv_parser_end(parser_);
 
             // Clear the environment reference after parsing
             rc_->env = nullptr;
         }
 
-        total_bytes_ = content.length();
+        total_bytes_ = content_len;
 
         return drainRows(env);
     }
@@ -916,6 +1151,7 @@ public:
 
         // Streaming writes produce row-callback data, not batch results.
         clearBatchResult();
+        clearFastRows();
 
         // Set environment for JS transforms
         rc_->env = env;
@@ -945,11 +1181,29 @@ public:
         // Buffer chunks when no transforms/iterator are active and batch-parse on end().
         // If buffered payload exceeds threshold, flush once to parser and continue streaming.
         if (!hasTransforms() && iterator_ == nullptr) {
-            if (chunk_size > SIZE_MAX - pending_stream_.size()) {
-                throw Napi::Error::New(env, "Buffered stream size would overflow");
-            }
-
             if (stream_buffering_active_) {
+                if (chunk_size > 0 && pending_stream_.empty() && pending_buffer_size_ == 0 && info[0].IsBuffer()) {
+                    auto buf = info[0].As<Napi::Buffer<uint8_t>>();
+                    pending_buffer_ref_ = Napi::Persistent(buf.As<Napi::Object>());
+                    pending_buffer_data_ = buf.Data();
+                    pending_buffer_size_ = buf.Length();
+                    total_bytes_ += chunk_size;
+                    return;
+                }
+
+                if (pending_buffer_size_ > 0) {
+                    if (pending_buffer_size_ > SIZE_MAX - pending_stream_.size()) {
+                        throw Napi::Error::New(env, "Buffered stream size would overflow");
+                    }
+                    pending_stream_.append(
+                        reinterpret_cast<const char*>(pending_buffer_data_),
+                        pending_buffer_size_);
+                    clearPendingBuffer();
+                }
+
+                if (chunk_size > SIZE_MAX - pending_stream_.size()) {
+                    throw Napi::Error::New(env, "Buffered stream size would overflow");
+                }
                 pending_stream_.append(reinterpret_cast<const char*>(chunk_data), chunk_size);
                 total_bytes_ += chunk_size;
 
@@ -959,7 +1213,7 @@ public:
                 }
                 return;
             }
-        } else if (!pending_stream_.empty()) {
+        } else if (!pending_stream_.empty() || pending_buffer_size_ > 0) {
             flushPendingStreamToParser();
             stream_buffering_active_ = false;
         }
@@ -977,6 +1231,21 @@ public:
         if (stream_buffering_active_ && !pending_stream_.empty() &&
             !hasTransforms() && iterator_ == nullptr &&
             rc_ && rc_->rows.empty() && rc_->current.empty()) {
+            napi_value fast_rows = nullptr;
+            if (tryParseSimpleLfToJsRows(
+                    info.Env(),
+                    reinterpret_cast<const uint8_t*>(pending_stream_.data()),
+                    pending_stream_.size(),
+                    config_,
+                    &fast_rows)) {
+                clearBatchResult();
+                clearFastRows();
+                fast_rows_ref_ = Napi::Persistent(Napi::Value(info.Env(), fast_rows).As<Napi::Object>());
+                pending_stream_.clear();
+                rc_->env = nullptr;
+                return;
+            }
+
             cisv_result_t *batch = cisv_parse_string_batch(
                 pending_stream_.data(), pending_stream_.size(), &config_);
             if (!batch) {
@@ -988,13 +1257,55 @@ public:
                 throw Napi::Error::New(info.Env(), msg);
             }
             clearBatchResult();
+            clearFastRows();
             batch_result_ = batch;
             pending_stream_.clear();
             rc_->env = nullptr;
             return;
         }
 
-        if (!pending_stream_.empty()) {
+        if (stream_buffering_active_ && pending_buffer_size_ > 0 &&
+            pending_stream_.empty() &&
+            !hasTransforms() && iterator_ == nullptr &&
+            rc_ && rc_->rows.empty() && rc_->current.empty()) {
+            napi_value fast_rows = nullptr;
+            if (tryParseSimpleLfToJsRows(
+                    info.Env(),
+                    pending_buffer_data_,
+                    pending_buffer_size_,
+                    config_,
+                    &fast_rows)) {
+                clearBatchResult();
+                clearFastRows();
+                fast_rows_ref_ = Napi::Persistent(Napi::Value(info.Env(), fast_rows).As<Napi::Object>());
+                clearPendingBuffer();
+                rc_->env = nullptr;
+                return;
+            }
+
+            cisv_result_t *batch = cisv_parse_string_batch(
+                reinterpret_cast<const char*>(pending_buffer_data_),
+                pending_buffer_size_,
+                &config_);
+            if (!batch) {
+                clearPendingBuffer();
+                throw Napi::Error::New(info.Env(), "parse error: " + std::string(strerror(errno)));
+            }
+            if (batch->error_code != 0) {
+                std::string msg = batch->error_message[0] ? batch->error_message : "parse error";
+                cisv_result_free(batch);
+                clearPendingBuffer();
+                throw Napi::Error::New(info.Env(), msg);
+            }
+            clearBatchResult();
+            clearFastRows();
+            batch_result_ = batch;
+            clearPendingBuffer();
+            rc_->env = nullptr;
+            return;
+        }
+
+        if (!pending_stream_.empty() || pending_buffer_size_ > 0) {
             flushPendingStreamToParser();
             stream_buffering_active_ = false;
         }
@@ -1016,18 +1327,24 @@ public:
             flushPendingStreamToParser();
             stream_buffering_active_ = false;
         }
+        if (pending_buffer_size_ > 0) {
+            flushPendingStreamToParser();
+            stream_buffering_active_ = false;
+        }
         return drainRows(info.Env());
     }
 
     void Clear(const Napi::CallbackInfo &info) {
         if (!is_destroyed_ && rc_) {
             clearBatchResult();
+            clearFastRows();
             rc_->rows.clear();
             rc_->current.clear();
             rc_->current_field_index = 0;
             total_bytes_ = 0;
             parse_time_ = 0;
             pending_stream_.clear();
+            clearPendingBuffer();
             stream_buffering_active_ = true;
             // Also clear the environment reference
             rc_->env = nullptr;
@@ -1074,8 +1391,6 @@ public:
                 type = TRANSFORM_TO_INT;
             } else if (transform_type == "to_float" || transform_type == "float") {
                 type = TRANSFORM_TO_FLOAT;
-            } else if (transform_type == "hash_sha256" || transform_type == "sha256") {
-                type = TRANSFORM_HASH_SHA256;
             } else if (transform_type == "base64_encode" || transform_type == "base64") {
                 type = TRANSFORM_BASE64_ENCODE;
             } else {
@@ -1185,8 +1500,6 @@ Napi::Value TransformByName(const Napi::CallbackInfo &info) {
             type = TRANSFORM_TO_INT;
         } else if (transform_type == "to_float" || transform_type == "float") {
             type = TRANSFORM_TO_FLOAT;
-        } else if (transform_type == "hash_sha256" || transform_type == "sha256") {
-            type = TRANSFORM_HASH_SHA256;
         } else if (transform_type == "base64_encode" || transform_type == "base64") {
             type = TRANSFORM_BASE64_ENCODE;
         } else {
@@ -1355,18 +1668,28 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
 
     std::string field_name = info[0].As<Napi::String>();
 
+    int field_index = -1;
+
     // Remove from JavaScript transforms by finding the field index
     if (rc_->pipeline && rc_->pipeline->header_fields) {
         for (size_t i = 0; i < rc_->pipeline->header_count; i++) {
             if (strcmp(rc_->pipeline->header_fields[i], field_name.c_str()) == 0) {
-                rc_->js_transforms.erase(i);
+                field_index = static_cast<int>(i);
+                auto it = rc_->js_transforms.find(field_index);
+                if (it != rc_->js_transforms.end()) {
+                    if (!it->second.IsEmpty()) {
+                        it->second.Reset();
+                    }
+                    rc_->js_transforms.erase(it);
+                }
                 break;
             }
         }
     }
 
-    // TODO: Implement removal of C transforms by name in cisv_transformer.c
-    // For now, this only removes JS transforms
+    if (field_index >= 0 && rc_->pipeline) {
+        cisv_transform_pipeline_remove_field(rc_->pipeline, field_index);
+    }
 
     return info.This();
 }
@@ -1385,10 +1708,17 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
         int field_index = info[0].As<Napi::Number>().Int32Value();
 
         // Remove from JavaScript transforms
-        rc_->js_transforms.erase(field_index);
+        auto it = rc_->js_transforms.find(field_index);
+        if (it != rc_->js_transforms.end()) {
+            if (!it->second.IsEmpty()) {
+                it->second.Reset();
+            }
+            rc_->js_transforms.erase(it);
+        }
 
-        // TODO: Implement removal of C transforms in cisv_transformer.c
-        // For now, this only removes JS transforms
+        if (rc_->pipeline) {
+            cisv_transform_pipeline_remove_field(rc_->pipeline, field_index);
+        }
 
         return info.This();
     }
@@ -1515,16 +1845,29 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
         result.Set("jsTransformCount", Napi::Number::New(env, js_transform_count));
 
         // List field indices with transforms
-        Napi::Array fields = Napi::Array::New(env);
-        size_t idx = 0;
+        std::vector<int> field_indices;
+        auto add_field_index = [&field_indices](int field_index) {
+            if (std::find(field_indices.begin(), field_indices.end(), field_index) == field_indices.end()) {
+                field_indices.push_back(field_index);
+            }
+        };
 
-        // Add JS transform field indices
+        if (rc_ && rc_->pipeline) {
+            for (size_t i = 0; i < rc_->pipeline->count; i++) {
+                add_field_index(rc_->pipeline->transforms[i].field_index);
+            }
+        }
         if (rc_) {
             for (const auto& pair : rc_->js_transforms) {
-                fields[idx++] = Napi::Number::New(env, pair.first);
+                add_field_index(pair.first);
             }
         }
 
+        Napi::Array fields = Napi::Array::New(env, field_indices.size());
+        for (size_t i = 0; i < field_indices.size(); i++) {
+            fields[i] = Napi::Number::New(env, field_indices[i]);
+        }
+
         result.Set("fieldIndices", fields);
 
         return result;
@@ -1540,7 +1883,16 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
         Napi::Object stats = Napi::Object::New(env);
         size_t row_count = 0;
         size_t field_count = 0;
-        if (batch_result_) {
+        if (!fast_rows_ref_.IsEmpty()) {
+            Napi::Array rows = fast_rows_ref_.Value().As<Napi::Array>();
+            row_count = rows.Length();
+            if (row_count > 0) {
+                Napi::Value first = rows.Get(static_cast<uint32_t>(0));
+                if (first.IsArray()) {
+                    field_count = first.As<Napi::Array>().Length();
+                }
+            }
+        } else if (batch_result_) {
             row_count = batch_result_->row_count;
             if (batch_result_->row_count > 0) {
                 field_count = batch_result_->rows[0].field_count;
@@ -1590,25 +1942,13 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
         cisv_config_init(&config);
 
         // Apply configuration if provided
+        if (info.Length() > 1 && !info[1].IsNull() && !info[1].IsUndefined() && !info[1].IsObject()) {
+            throw Napi::TypeError::New(env, "Config must be an object");
+        }
+
         if (info.Length() > 1 && info[1].IsObject()) {
             Napi::Object options = info[1].As<Napi::Object>();
-
-            // Apply same configuration parsing logic
-            ValidateSingleCharOption(env, options, "delimiter", &config.delimiter);
-            ValidateSingleCharOption(env, options, "quote", &config.quote);
-            ValidateSingleCharOption(env, options, "comment", &config.comment, true);
-
-            if (options.Has("skipEmptyLines")) {
-                config.skip_empty_lines = options.Get("skipEmptyLines").As<Napi::Boolean>();
-            }
-
-            if (options.Has("fromLine")) {
-                config.from_line = options.Get("fromLine").As<Napi::Number>().Int32Value();
-            }
-
-            if (options.Has("toLine")) {
-                config.to_line = options.Get("toLine").As<Napi::Number>().Int32Value();
-            }
+            ApplyConfigOptions(env, options, &config);
         }
 
         size_t count = cisv_parser_count_rows_with_config(path.c_str(), &config);
@@ -1684,8 +2024,15 @@ Napi::Value RemoveTransformByName(const Napi::CallbackInfo &info) {
 
         napi_value row;
         napi_create_array_with_length(env, field_count, &row);
+        bool ascii_only = true;
         for (size_t i = 0; i < field_count; i++) {
-            napi_set_element(env, row, i, SafeNewStringValue(env, fields[i], lengths[i]));
+            if (!isAllAscii(fields[i], lengths[i])) {
+                ascii_only = false;
+                break;
+            }
+        }
+        for (size_t i = 0; i < field_count; i++) {
+            napi_set_element(env, row, i, NewCsvStringValue(env, fields[i], lengths[i], ascii_only));
         }
 
         return Napi::Value(env, row);
@@ -1734,6 +2081,20 @@ private:
         }
     }
 
+    void clearFastRows() {
+        if (!fast_rows_ref_.IsEmpty()) {
+            fast_rows_ref_.Reset();
+        }
+    }
+
+    void clearPendingBuffer() {
+        if (!pending_buffer_ref_.IsEmpty()) {
+            pending_buffer_ref_.Reset();
+        }
+        pending_buffer_data_ = nullptr;
+        pending_buffer_size_ = 0;
+    }
+
     bool hasTransforms() const {
         bool has_c_transforms = rc_ && rc_->pipeline && rc_->pipeline->count > 0;
         bool has_js_transforms = rc_ && !rc_->js_transforms.empty();
@@ -1742,7 +2103,9 @@ private:
 
     void resetRowState() {
         clearBatchResult();
+        clearFastRows();
         pending_stream_.clear();
+        clearPendingBuffer();
         stream_buffering_active_ = true;
         if (!rc_) return;
         rc_->rows.clear();
@@ -1751,6 +2114,11 @@ private:
     }
 
     void flushPendingStreamToParser() {
+        if (pending_buffer_size_ > 0) {
+            ensureParser(Env());
+            cisv_parser_write(parser_, pending_buffer_data_, pending_buffer_size_);
+            clearPendingBuffer();
+        }
         if (pending_stream_.empty()) {
             return;
         }
@@ -1779,15 +2147,27 @@ private:
     }
 
     Napi::Value drainRows(Napi::Env env) {
+        if (!fast_rows_ref_.IsEmpty()) {
+            return fast_rows_ref_.Value();
+        }
+
         if (batch_result_) {
             napi_value rows;
             napi_create_array_with_length(env, batch_result_->row_count, &rows);
+            const bool ascii_only =
+                !batch_result_->field_data ||
+                batch_result_->field_data_size == 0 ||
+                isAllAscii(batch_result_->field_data, batch_result_->field_data_size);
             for (size_t i = 0; i < batch_result_->row_count; ++i) {
                 const cisv_row_t *src_row = &batch_result_->rows[i];
                 napi_value row;
                 napi_create_array_with_length(env, src_row->field_count, &row);
                 for (size_t j = 0; j < src_row->field_count; ++j) {
-                    napi_set_element(env, row, j, SafeNewStringValue(env, src_row->fields[j], src_row->field_lengths[j]));
+                    napi_set_element(
+                        env,
+                        row,
+                        j,
+                        NewCsvStringValue(env, src_row->fields[j], src_row->field_lengths[j], ascii_only));
                 }
                 napi_set_element(env, rows, i, row);
             }
@@ -1800,6 +2180,7 @@ private:
 
         napi_value rows;
         napi_create_array_with_length(env, rc_->rows.size(), &rows);
+        const bool ascii_only = rowsAreAscii(rc_->rows);
 
         for (size_t i = 0; i < rc_->rows.size(); ++i) {
             napi_value row;
@@ -1807,7 +2188,11 @@ private:
             for (size_t j = 0; j < rc_->rows[i].size(); ++j) {
                 // SECURITY: Use safe string creation to handle invalid UTF-8 in CSV data
                 const std::string& field = rc_->rows[i][j];
-                napi_set_element(env, row, j, SafeNewStringValue(env, field.c_str(), field.length()));
+                napi_set_element(
+                    env,
+                    row,
+                    j,
+                    NewCsvStringValue(env, field.c_str(), field.length(), ascii_only));
             }
             napi_set_element(env, rows, i, row);
         }
@@ -1826,7 +2211,11 @@ private:
     bool is_destroyed_;
     cisv_iterator_t *iterator_;  // For row-by-row iteration
     cisv_result_t *batch_result_;
+    Napi::ObjectReference fast_rows_ref_;
     std::string pending_stream_;
+    Napi::ObjectReference pending_buffer_ref_;
+    const uint8_t *pending_buffer_data_;
+    size_t pending_buffer_size_;
     bool stream_buffering_active_;
     static constexpr size_t kStreamBufferLimitBytes = 8 * 1024 * 1024;
 };
@@ -1836,7 +2225,7 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
     CisvParser::Init(env, exports);
 
     // Add version info
-    exports.Set("version", Napi::String::New(env, "0.4.8"));
+    exports.Set("version", Napi::String::New(env, "0.4.9"));
 
     // Add transform type constants
     Napi::Object transformTypes = Napi::Object::New(env);
@@ -1845,7 +2234,6 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
     transformTypes.Set("TRIM", Napi::String::New(env, "trim"));
     transformTypes.Set("TO_INT", Napi::String::New(env, "to_int"));
     transformTypes.Set("TO_FLOAT", Napi::String::New(env, "to_float"));
-    transformTypes.Set("HASH_SHA256", Napi::String::New(env, "hash_sha256"));
     transformTypes.Set("BASE64_ENCODE", Napi::String::New(env, "base64_encode"));
     exports.Set("TransformType", transformTypes);
 

package/cisv/index.js

@@ -1,4 +1,5 @@
 const path = require('path');
 const addon = require('node-gyp-build')(path.join(__dirname, '..'));
+const { wrapAddon } = require('./wrapper');
 
-module.exports = addon;
+module.exports = wrapAddon(addon);

package/cisv/index.mjs

@@ -7,6 +7,10 @@ const require = createRequire(import.meta.url);
 
 const gyp = require('node-gyp-build');
 const addon = gyp(path.join(__dirname, '..'));
+const { wrapAddon } = require('./wrapper.js');
+const wrapped = wrapAddon(addon);
 
-export const cisvParser = addon.cisvParser;
-export default addon;
+export const cisvParser = wrapped.cisvParser;
+export const TransformType = wrapped.TransformType;
+export const version = wrapped.version;
+export default wrapped;

package/cisv/types/cisv.d.ts

@@ -8,7 +8,6 @@ declare module 'cisv' {
     TRIM = 'trim',
     TO_INT = 'to_int',
     TO_FLOAT = 'to_float',
-    HASH_SHA256 = 'hash_sha256',
     BASE64_ENCODE = 'base64_encode',
     CUSTOM = 'custom'
   }
@@ -88,11 +87,11 @@ declare module 'cisv' {
     parseParallel(path: string, numThreads?: number): Promise<string[][]>;
 
     /**
-     * Parse CSV string content
-     * @param content CSV string content
+     * Parse CSV string or Buffer content
+     * @param content CSV content as string or Buffer
      * @returns Array of rows with string values
      */
-    parseString(content: string): string[][];
+    parseString(content: Buffer | string): string[][];
 
     /**
      * Write chunk of CSV data (for streaming)

package/cisv/wrapper.js

@@ -0,0 +1,371 @@
+'use strict';
+
+const { isAscii } = require('buffer');
+
+function fastConfigFromOptions(options) {
+  if (options == null) {
+    return { delimiter: ',', quote: '"' };
+  }
+  if (typeof options !== 'object') {
+    return null;
+  }
+
+  const delimiter = options.delimiter == null ? ',' : options.delimiter;
+  const quote = options.quote == null ? '"' : options.quote;
+  if (typeof delimiter !== 'string' || delimiter.length !== 1) {
+    return null;
+  }
+  if (typeof quote !== 'string' || quote.length !== 1) {
+    return null;
+  }
+
+  if (options.escape != null && options.escape !== '') {
+    return null;
+  }
+  if (options.comment != null && options.comment !== '') {
+    return null;
+  }
+  if (options.trim || options.skipEmptyLines || options.relaxed || options.skipLinesWithError) {
+    return null;
+  }
+  if (options.maxRowSize != null && options.maxRowSize !== 0) {
+    return null;
+  }
+
+  const fromLine = options.fromLine == null ? 1 : options.fromLine;
+  const toLine = options.toLine == null ? 0 : options.toLine;
+  if (fromLine !== 0 && fromLine !== 1) {
+    return null;
+  }
+  if (toLine !== 0) {
+    return null;
+  }
+
+  return { delimiter, quote };
+}
+
+function chunkToLatin1String(chunk) {
+  return Buffer.isBuffer(chunk) ? chunk.toString('latin1') : chunk;
+}
+
+function chunksToLatin1String(chunks) {
+  if (chunks.length === 1) {
+    return chunkToLatin1String(chunks[0]);
+  }
+
+  let out = '';
+  for (let i = 0; i < chunks.length; i++) {
+    out += chunkToLatin1String(chunks[i]);
+  }
+  return out;
+}
+
+function isSimpleAsciiLf(data, quote) {
+  if (data.length >= 3 &&
+      data.charCodeAt(0) === 0xEF &&
+      data.charCodeAt(1) === 0xBB &&
+      data.charCodeAt(2) === 0xBF) {
+    return false;
+  }
+
+  const quoteCode = quote.charCodeAt(0);
+  for (let i = 0; i < data.length; i++) {
+    const code = data.charCodeAt(i);
+    if (code === quoteCode || code === 13 || code > 127) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function chunksAreSimpleAsciiLf(chunks, quote) {
+  const quoteCode = quote.charCodeAt(0);
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i];
+    if (Buffer.isBuffer(chunk)) {
+      if (i === 0 &&
+          chunk.length >= 3 &&
+          chunk[0] === 0xEF &&
+          chunk[1] === 0xBB &&
+          chunk[2] === 0xBF) {
+        return false;
+      }
+      if (!isAscii(chunk) || chunk.indexOf(quoteCode) !== -1 || chunk.indexOf(13) !== -1) {
+        return false;
+      }
+    } else if (!isSimpleAsciiLf(chunk, quote)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function analyzeSingleSimpleChunk(chunk, delimiter, quote) {
+  const delimiterCode = delimiter.charCodeAt(0);
+  const quoteCode = quote.charCodeAt(0);
+  let cols = -1;
+  let currentCols = 1;
+  let hasData = false;
+  let rows = 0;
+
+  if (Buffer.isBuffer(chunk)) {
+    if (chunk.length >= 3 && chunk[0] === 0xEF && chunk[1] === 0xBB && chunk[2] === 0xBF) {
+      return { simple: false, uniform: false, rows: 0, cols: 0 };
+    }
+    for (let i = 0; i < chunk.length; i++) {
+      const code = chunk[i];
+      if (code === quoteCode || code === 13 || code > 127) {
+        return { simple: false, uniform: false, rows: 0, cols: 0 };
+      }
+      if (code === delimiterCode) {
+        currentCols++;
+        hasData = true;
+      } else if (code === 10) {
+        if (cols === -1) {
+          cols = currentCols;
+        } else if (currentCols !== cols) {
+          return { simple: true, uniform: false, rows: 0, cols: 0 };
+        }
+        rows++;
+        currentCols = 1;
+        hasData = false;
+      } else {
+        hasData = true;
+      }
+    }
+  } else {
+    if (chunk.length >= 3 &&
+        chunk.charCodeAt(0) === 0xEF &&
+        chunk.charCodeAt(1) === 0xBB &&
+        chunk.charCodeAt(2) === 0xBF) {
+      return { simple: false, uniform: false, rows: 0, cols: 0 };
+    }
+    for (let i = 0; i < chunk.length; i++) {
+      const code = chunk.charCodeAt(i);
+      if (code === quoteCode || code === 13 || code > 127) {
+        return { simple: false, uniform: false, rows: 0, cols: 0 };
+      }
+      if (code === delimiterCode) {
+        currentCols++;
+        hasData = true;
+      } else if (code === 10) {
+        if (cols === -1) {
+          cols = currentCols;
+        } else if (currentCols !== cols) {
+          return { simple: true, uniform: false, rows: 0, cols: 0 };
+        }
+        rows++;
+        currentCols = 1;
+        hasData = false;
+      } else {
+        hasData = true;
+      }
+    }
+  }
+
+  if (hasData && cols !== -1 && currentCols !== cols) {
+    return { simple: true, uniform: false, rows: 0, cols: 0 };
+  }
+  if (hasData) {
+    rows++;
+    if (cols === -1) {
+      cols = currentCols;
+    }
+  }
+
+  return { simple: true, uniform: true, rows, cols: Math.max(cols, 0) };
+}
+
+function parseSimpleRows(data, delimiter) {
+  if (data.length === 0) {
+    return [];
+  }
+
+  const last = data.charCodeAt(data.length - 1);
+  const body = last === 10 ? data.slice(0, -1) : data;
+  if (body.length === 0) {
+    return [['']];
+  }
+
+  const lines = body.split('\n');
+  const rows = new Array(lines.length);
+  for (let i = 0; i < lines.length; i++) {
+    rows[i] = lines[i].split(delimiter);
+  }
+  return rows;
+}
+
+function parseUniformRows(data, delimiter, rowCount, cols) {
+  let end = data.length;
+  if (end === 0) {
+    return [];
+  }
+  if (data.charCodeAt(end - 1) === 10) {
+    end--;
+  }
+  if (end === 0) {
+    return [['']];
+  }
+
+  const usePrealloc = rowCount > 0 && cols > 0;
+  if (!usePrealloc) {
+    cols = 1;
+    for (let i = 0; i < end && data.charCodeAt(i) !== 10; i++) {
+      if (data[i] === delimiter) {
+        cols++;
+      }
+    }
+  }
+
+  const rows = usePrealloc ? new Array(rowCount) : [];
+  let rowIdx = 0;
+  let pos = 0;
+  while (pos < end) {
+    const row = new Array(cols);
+    for (let col = 0; col < cols - 1; col++) {
+      const next = data.indexOf(delimiter, pos);
+      row[col] = data.slice(pos, next);
+      pos = next + 1;
+    }
+
+    let lineEnd = data.indexOf('\n', pos);
+    if (lineEnd === -1 || lineEnd > end) {
+      lineEnd = end;
+    }
+    row[cols - 1] = data.slice(pos, lineEnd);
+    if (usePrealloc) {
+      rows[rowIdx++] = row;
+    } else {
+      rows.push(row);
+    }
+    pos = lineEnd + 1;
+  }
+
+  return rows;
+}
+
+function wrapAddon(addon) {
+  const NativeParser = addon.cisvParser;
+
+  class cisvParser extends NativeParser {
+    constructor(options) {
+      super(options);
+      this._cisvFastConfig = fastConfigFromOptions(options);
+      this._cisvFastChunks = [];
+      this._cisvFastRows = null;
+      this._cisvNativeStream = false;
+    }
+
+    _flushFastChunksToNative() {
+      if (this._cisvFastChunks.length === 0) {
+        return;
+      }
+      const chunks = this._cisvFastChunks;
+      this._cisvFastChunks = [];
+      this._cisvNativeStream = true;
+      for (let i = 0; i < chunks.length; i++) {
+        super.write(chunks[i]);
+      }
+    }
+
+    write(chunk) {
+      this._cisvFastRows = null;
+      if (this._cisvFastConfig &&
+          !this._cisvNativeStream &&
+          (Buffer.isBuffer(chunk) || typeof chunk === 'string')) {
+        this._cisvFastChunks.push(chunk);
+        return;
+      }
+
+      this._flushFastChunksToNative();
+      this._cisvNativeStream = true;
+      return super.write(chunk);
+    }
+
+    end() {
+      if (this._cisvFastConfig &&
+          !this._cisvNativeStream &&
+          this._cisvFastChunks.length > 0) {
+        let uniform = false;
+        let simple = false;
+
+        if (this._cisvFastChunks.length === 1) {
+          const analysis = analyzeSingleSimpleChunk(
+            this._cisvFastChunks[0],
+            this._cisvFastConfig.delimiter,
+            this._cisvFastConfig.quote);
+          simple = analysis.simple;
+          uniform = analysis.uniform;
+          var rowCount = analysis.rows;
+          var colCount = analysis.cols;
+        } else {
+          simple = chunksAreSimpleAsciiLf(this._cisvFastChunks, this._cisvFastConfig.quote);
+        }
+
+        if (simple) {
+          const data = chunksToLatin1String(this._cisvFastChunks);
+          const useLargePrealloc = data.length >= 64 * 1024 * 1024;
+          this._cisvFastRows = uniform
+            ? parseUniformRows(
+                data,
+                this._cisvFastConfig.delimiter,
+                useLargePrealloc ? rowCount : 0,
+                useLargePrealloc ? colCount : 0)
+            : parseSimpleRows(data, this._cisvFastConfig.delimiter);
+          this._cisvFastChunks = [];
+          return;
+        }
+      }
+
+      this._flushFastChunksToNative();
+      this._cisvNativeStream = true;
+      return super.end();
+    }
+
+    getRows() {
+      if (this._cisvFastRows !== null) {
+        return this._cisvFastRows;
+      }
+      return super.getRows();
+    }
+
+    clear() {
+      this._cisvFastChunks = [];
+      this._cisvFastRows = null;
+      this._cisvNativeStream = false;
+      return super.clear();
+    }
+
+    setConfig(options) {
+      this._flushFastChunksToNative();
+      this._cisvFastRows = null;
+      this._cisvFastConfig = fastConfigFromOptions(options);
+      return super.setConfig(options);
+    }
+
+    transform(...args) {
+      this._flushFastChunksToNative();
+      this._cisvFastConfig = null;
+      return super.transform(...args);
+    }
+
+    transformByName(...args) {
+      this._flushFastChunksToNative();
+      this._cisvFastConfig = null;
+      return super.transformByName(...args);
+    }
+
+    destroy() {
+      this._cisvFastChunks = [];
+      this._cisvFastRows = null;
+      return super.destroy();
+    }
+  }
+
+  return {
+    ...addon,
+    cisvParser,
+  };
+}
+
+module.exports = { wrapAddon };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cisv",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "The csv parser on steroids.",
   "author": "sanix<s4nixd@gmail.com>",
   "main": "./build/Release/cisv.node",