@loaders.gl/csv 4.3.0-alpha.8 → 4.3.0-beta.1

package/dist/dist.dev.js

@@ -626,32 +626,7 @@ var __exports__ = (() => {
 
   // src/papaparse/papaparse.ts
   var BYTE_ORDER_MARK = "\uFEFF";
-  var Papa = {
-    parse: CsvToJson,
-    unparse: JsonToCsv,
-    RECORD_SEP: String.fromCharCode(30),
-    UNIT_SEP: String.fromCharCode(31),
-    BYTE_ORDER_MARK,
-    BAD_DELIMITERS: ["\r", "\n", '"', BYTE_ORDER_MARK],
-    WORKERS_SUPPORTED: false,
-    // !IS_WORKER && !!globalThis.Worker
-    NODE_STREAM_INPUT: 1,
-    // Configurable chunk sizes for local and remote files, respectively
-    LocalChunkSize: 1024 * 1024 * 10,
-    // 10 M,
-    RemoteChunkSize: 1024 * 1024 * 5,
-    // 5 M,
-    DefaultDelimiter: ",",
-    // Used if not specified and detection fail,
-    // Exposed for testing and development only
-    Parser,
-    ParserHandle,
-    // BEGIN FORK
-    ChunkStreamer,
-    StringStreamer
-  };
-  var papaparse_default = Papa;
-  function CsvToJson(_input, _config, UserDefinedStreamer) {
+  function CsvToJson(_input, _config = {}, Streamer = StringStreamer) {
     _config = _config || {};
     var dynamicTyping = _config.dynamicTyping || false;
     if (isFunction(dynamicTyping)) {
@@ -660,31 +635,7 @@ var __exports__ = (() => {
     }
     _config.dynamicTyping = dynamicTyping;
     _config.transform = isFunction(_config.transform) ? _config.transform : false;
-    if (_config.worker && Papa.WORKERS_SUPPORTED) {
-      var w = newWorker();
-      w.userStep = _config.step;
-      w.userChunk = _config.chunk;
-      w.userComplete = _config.complete;
-      w.userError = _config.error;
-      _config.step = isFunction(_config.step);
-      _config.chunk = isFunction(_config.chunk);
-      _config.complete = isFunction(_config.complete);
-      _config.error = isFunction(_config.error);
-      delete _config.worker;
-      w.postMessage({
-        input: _input,
-        config: _config,
-        workerId: w.id
-      });
-      return;
-    }
-    var streamer = null;
-    if (typeof _input === "string") {
-      streamer = new StringStreamer(_config);
-    }
-    if (!streamer) {
-      streamer = new UserDefinedStreamer(_config);
-    }
+    var streamer = new Streamer(_config);
     return streamer.stream(_input);
   }
   function JsonToCsv(_input, _config) {
@@ -704,7 +655,7 @@ var __exports__ = (() => {
       if (!_input.length || Array.isArray(_input[0]))
         return serialize(null, _input, _skipEmptyLines);
       else if (typeof _input[0] === "object")
-        return serialize(_columns || objectKeys(_input[0]), _input, _skipEmptyLines);
+        return serialize(_columns || Object.keys(_input[0]), _input, _skipEmptyLines);
     } else if (typeof _input === "object") {
       if (typeof _input.data === "string")
         _input.data = JSON.parse(_input.data);
@@ -712,7 +663,7 @@ var __exports__ = (() => {
         if (!_input.fields)
           _input.fields = _input.meta && _input.meta.fields;
         if (!_input.fields)
-          _input.fields = Array.isArray(_input.data[0]) ? _input.fields : objectKeys(_input.data[0]);
+          _input.fields = Array.isArray(_input.data[0]) ? _input.fields : Object.keys(_input.data[0]);
         if (!Array.isArray(_input.data[0]) && typeof _input.data[0] !== "object")
           _input.data = [_input.data];
       }
@@ -746,14 +697,6 @@ var __exports__ = (() => {
         _escapedQuote = _config.escapeChar + _quoteChar;
       }
     }
-    function objectKeys(obj) {
-      if (typeof obj !== "object")
-        return [];
-      var keys = [];
-      for (var key in obj)
-        keys.push(key);
-      return keys;
-    }
     function serialize(fields, data, skipEmptyLines) {
       var csv2 = "";
       if (typeof fields === "string")
@@ -816,24 +759,33 @@ var __exports__ = (() => {
       return false;
     }
   }
-  function ChunkStreamer(config) {
-    this._handle = null;
-    this._finished = false;
-    this._completed = false;
-    this._input = null;
-    this._baseIndex = 0;
-    this._partialLine = "";
-    this._rowCount = 0;
-    this._start = 0;
-    this._nextChunk = null;
-    this.isFirstChunk = true;
-    this._completeResults = {
+  var ChunkStreamer = class {
+    _handle;
+    _config;
+    _finished = false;
+    _completed = false;
+    _input = null;
+    _baseIndex = 0;
+    _partialLine = "";
+    _rowCount = 0;
+    _start = 0;
+    isFirstChunk = true;
+    _completeResults = {
       data: [],
       errors: [],
       meta: {}
     };
-    replaceConfig.call(this, config);
-    this.parseChunk = function(chunk, isFakeChunk) {
+    constructor(config) {
+      var configCopy = { ...config };
+      configCopy.chunkSize = parseInt(configCopy.chunkSize);
+      if (!config.step && !config.chunk) {
+        configCopy.chunkSize = null;
+      }
+      this._handle = new ParserHandle(configCopy);
+      this._handle.streamer = this;
+      this._config = configCopy;
+    }
+    parseChunk(chunk, isFakeChunk) {
       if (this.isFirstChunk && isFunction(this._config.beforeFirstChunk)) {
         var modifiedChunk = this._config.beforeFirstChunk(chunk);
         if (modifiedChunk !== void 0)
@@ -869,183 +821,191 @@ var __exports__ = (() => {
         this._config.complete(this._completeResults, this._input);
         this._completed = true;
       }
-      if (!finishedIncludingPreview && (!results || !results.meta.paused))
-        this._nextChunk();
       return results;
-    };
-    this._sendError = function(error) {
+    }
+    _sendError(error) {
       if (isFunction(this._config.error))
         this._config.error(error);
-    };
-    function replaceConfig(config2) {
-      var configCopy = copy(config2);
-      configCopy.chunkSize = parseInt(configCopy.chunkSize);
-      if (!config2.step && !config2.chunk)
-        configCopy.chunkSize = null;
-      this._handle = new ParserHandle(configCopy);
-      this._handle.streamer = this;
-      this._config = configCopy;
     }
-  }
-  function StringStreamer(config) {
-    config = config || {};
-    ChunkStreamer.call(this, config);
-    var remaining;
-    this.stream = function(s) {
-      remaining = s;
+  };
+  var StringStreamer = class extends ChunkStreamer {
+    remaining;
+    constructor(config = {}) {
+      super(config);
+    }
+    stream(s) {
+      this.remaining = s;
       return this._nextChunk();
-    };
-    this._nextChunk = function() {
+    }
+    _nextChunk() {
       if (this._finished)
         return;
       var size = this._config.chunkSize;
-      var chunk = size ? remaining.substr(0, size) : remaining;
-      remaining = size ? remaining.substr(size) : "";
-      this._finished = !remaining;
+      var chunk = size ? this.remaining.substr(0, size) : this.remaining;
+      this.remaining = size ? this.remaining.substr(size) : "";
+      this._finished = !this.remaining;
       return this.parseChunk(chunk);
-    };
-  }
-  StringStreamer.prototype = Object.create(StringStreamer.prototype);
-  StringStreamer.prototype.constructor = StringStreamer;
-  function ParserHandle(_config) {
-    var FLOAT = /^\s*-?(\d*\.?\d+|\d+\.?\d*)(e[-+]?\d+)?\s*$/i;
-    var ISO_DATE = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/;
-    var self = this;
-    var _stepCounter = 0;
-    var _rowCounter = 0;
-    var _input;
-    var _parser;
-    var _paused = false;
-    var _aborted = false;
-    var _delimiterError;
-    var _fields = [];
-    var _results = {
-      // The last results returned from the parser
+    }
+  };
+  var FLOAT = /^\s*-?(\d*\.?\d+|\d+\.?\d*)(e[-+]?\d+)?\s*$/i;
+  var ISO_DATE = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/;
+  var ParserHandle = class {
+    _config;
+    /** Number of times step was called (number of rows parsed) */
+    _stepCounter = 0;
+    /** Number of rows that have been parsed so far */
+    _rowCounter = 0;
+    /** The input being parsed */
+    _input;
+    /** The core parser being used */
+    _parser;
+    /** Whether we are paused or not */
+    _paused = false;
+    /** Whether the parser has aborted or not */
+    _aborted = false;
+    /** Temporary state between delimiter detection and processing results */
+    _delimiterError = false;
+    /** Fields are from the header row of the input, if there is one */
+    _fields = [];
+    /** The last results returned from the parser */
+    _results = {
       data: [],
       errors: [],
       meta: {}
     };
-    if (isFunction(_config.step)) {
-      var userStep = _config.step;
-      _config.step = function(results) {
-        _results = results;
-        if (needsHeaderRow())
-          processResults();
-        else {
-          processResults();
-          if (!_results.data || _results.data.length === 0)
-            return;
-          _stepCounter += results.data.length;
-          if (_config.preview && _stepCounter > _config.preview)
-            _parser.abort();
-          else
-            userStep(_results, self);
-        }
-      };
+    constructor(_config) {
+      if (isFunction(_config.step)) {
+        var userStep = _config.step;
+        _config.step = (results) => {
+          this._results = results;
+          if (this.needsHeaderRow()) {
+            this.processResults();
+          } else {
+            this.processResults();
+            if (!this._results.data || this._results.data.length === 0)
+              return;
+            this._stepCounter += results.data.length;
+            if (_config.preview && this._stepCounter > _config.preview) {
+              this._parser.abort();
+            } else {
+              userStep(this._results, this);
+            }
+          }
+        };
+      }
+      this._config = _config;
     }
-    this.parse = function(input, baseIndex, ignoreLastRow) {
-      var quoteChar = _config.quoteChar || '"';
-      if (!_config.newline)
-        _config.newline = guessLineEndings(input, quoteChar);
-      _delimiterError = false;
-      if (!_config.delimiter) {
-        var delimGuess = guessDelimiter(
+    /**
+     * Parses input. Most users won't need, and shouldn't mess with, the baseIndex
+     * and ignoreLastRow parameters. They are used by streamers (wrapper functions)
+     * when an input comes in multiple chunks, like from a file.
+     */
+    parse(input, baseIndex, ignoreLastRow) {
+      var quoteChar = this._config.quoteChar || '"';
+      if (!this._config.newline)
+        this._config.newline = guessLineEndings(input, quoteChar);
+      this._delimiterError = false;
+      if (!this._config.delimiter) {
+        var delimGuess = this.guessDelimiter(
           input,
-          _config.newline,
-          _config.skipEmptyLines,
-          _config.comments,
-          _config.delimitersToGuess
+          this._config.newline,
+          this._config.skipEmptyLines,
+          this._config.comments,
+          this._config.delimitersToGuess
         );
-        if (delimGuess.successful)
-          _config.delimiter = delimGuess.bestDelimiter;
-        else {
-          _delimiterError = true;
-          _config.delimiter = Papa.DefaultDelimiter;
+        if (delimGuess.successful) {
+          this._config.delimiter = delimGuess.bestDelimiter;
+        } else {
+          this._delimiterError = true;
+          this._config.delimiter = Papa.DefaultDelimiter;
         }
-        _results.meta.delimiter = _config.delimiter;
-      } else if (isFunction(_config.delimiter)) {
-        _config.delimiter = _config.delimiter(input);
-        _results.meta.delimiter = _config.delimiter;
+        this._results.meta.delimiter = this._config.delimiter;
+      } else if (isFunction(this._config.delimiter)) {
+        this._config.delimiter = this._config.delimiter(input);
+        this._results.meta.delimiter = this._config.delimiter;
       }
-      var parserConfig = copy(_config);
-      if (_config.preview && _config.header)
+      var parserConfig = copy(this._config);
+      if (this._config.preview && this._config.header)
         parserConfig.preview++;
-      _input = input;
-      _parser = new Parser(parserConfig);
-      _results = _parser.parse(_input, baseIndex, ignoreLastRow);
-      processResults();
-      return _paused ? { meta: { paused: true } } : _results || { meta: { paused: false } };
-    };
-    this.paused = function() {
-      return _paused;
-    };
-    this.pause = function() {
-      _paused = true;
-      _parser.abort();
-      _input = _input.substr(_parser.getCharIndex());
-    };
-    this.resume = function() {
-      _paused = false;
-      self.streamer.parseChunk(_input, true);
-    };
-    this.aborted = function() {
-      return _aborted;
-    };
-    this.abort = function() {
-      _aborted = true;
-      _parser.abort();
-      _results.meta.aborted = true;
-      if (isFunction(_config.complete))
-        _config.complete(_results);
-      _input = "";
-    };
-    function testEmptyLine(s) {
-      return _config.skipEmptyLines === "greedy" ? s.join("").trim() === "" : s.length === 1 && s[0].length === 0;
-    }
-    function processResults() {
-      if (_results && _delimiterError) {
-        addError(
+      this._input = input;
+      this._parser = new Parser(parserConfig);
+      this._results = this._parser.parse(this._input, baseIndex, ignoreLastRow);
+      this.processResults();
+      return this._paused ? { meta: { paused: true } } : this._results || { meta: { paused: false } };
+    }
+    paused() {
+      return this._paused;
+    }
+    pause() {
+      this._paused = true;
+      this._parser.abort();
+      this._input = this._input.substr(this._parser.getCharIndex());
+    }
+    resume() {
+      this._paused = false;
+      this.streamer.parseChunk(this._input, true);
+    }
+    aborted() {
+      return this._aborted;
+    }
+    abort() {
+      this._aborted = true;
+      this._parser.abort();
+      this._results.meta.aborted = true;
+      if (isFunction(this._config.complete)) {
+        this._config.complete(this._results);
+      }
+      this._input = "";
+    }
+    testEmptyLine(s) {
+      return this._config.skipEmptyLines === "greedy" ? s.join("").trim() === "" : s.length === 1 && s[0].length === 0;
+    }
+    processResults() {
+      if (this._results && this._delimiterError) {
+        this.addError(
           "Delimiter",
           "UndetectableDelimiter",
           "Unable to auto-detect delimiting character; defaulted to '" + Papa.DefaultDelimiter + "'"
         );
-        _delimiterError = false;
+        this._delimiterError = false;
+      }
+      if (this._config.skipEmptyLines) {
+        for (var i = 0; i < this._results.data.length; i++)
+          if (this.testEmptyLine(this._results.data[i]))
+            this._results.data.splice(i--, 1);
       }
-      if (_config.skipEmptyLines) {
-        for (var i = 0; i < _results.data.length; i++)
-          if (testEmptyLine(_results.data[i]))
-            _results.data.splice(i--, 1);
+      if (this.needsHeaderRow()) {
+        this.fillHeaderFields();
       }
-      if (needsHeaderRow())
-        fillHeaderFields();
-      return applyHeaderAndDynamicTypingAndTransformation();
+      return this.applyHeaderAndDynamicTypingAndTransformation();
     }
-    function needsHeaderRow() {
-      return _config.header && _fields.length === 0;
+    needsHeaderRow() {
+      return this._config.header && this._fields.length === 0;
     }
-    function fillHeaderFields() {
-      if (!_results)
+    fillHeaderFields() {
+      if (!this._results)
         return;
-      function addHeder(header) {
-        if (isFunction(_config.transformHeader))
-          header = _config.transformHeader(header);
-        _fields.push(header);
-      }
-      if (Array.isArray(_results.data[0])) {
-        for (var i = 0; needsHeaderRow() && i < _results.data.length; i++)
-          _results.data[i].forEach(addHeder);
-        _results.data.splice(0, 1);
-      } else
-        _results.data.forEach(addHeder);
-    }
-    function shouldApplyDynamicTyping(field) {
-      if (_config.dynamicTypingFunction && _config.dynamicTyping[field] === void 0) {
-        _config.dynamicTyping[field] = _config.dynamicTypingFunction(field);
-      }
-      return (_config.dynamicTyping[field] || _config.dynamicTyping) === true;
-    }
-    function parseDynamic(field, value) {
-      if (shouldApplyDynamicTyping(field)) {
+      const addHeder = (header) => {
+        if (isFunction(this._config.transformHeader))
+          header = this._config.transformHeader(header);
+        this._fields.push(header);
+      };
+      if (Array.isArray(this._results.data[0])) {
+        for (var i = 0; this.needsHeaderRow() && i < this._results.data.length; i++)
+          this._results.data[i].forEach(addHeder);
+        this._results.data.splice(0, 1);
+      } else {
+        this._results.data.forEach(addHeder);
+      }
+    }
+    shouldApplyDynamicTyping(field) {
+      if (this._config.dynamicTypingFunction && this._config.dynamicTyping[field] === void 0) {
+        this._config.dynamicTyping[field] = this._config.dynamicTypingFunction(field);
+      }
+      return (this._config.dynamicTyping[field] || this._config.dynamicTyping) === true;
+    }
+    parseDynamic(field, value) {
+      if (this.shouldApplyDynamicTyping(field)) {
         if (value === "true" || value === "TRUE")
           return true;
         else if (value === "false" || value === "FALSE")
@@ -1059,56 +1019,58 @@ var __exports__ = (() => {
       }
       return value;
     }
-    function applyHeaderAndDynamicTypingAndTransformation() {
-      if (!_results || !_results.data || !_config.header && !_config.dynamicTyping && !_config.transform)
-        return _results;
-      function processRow(rowSource, i) {
-        var row = _config.header ? {} : [];
-        var j;
-        for (j = 0; j < rowSource.length; j++) {
-          var field = j;
-          var value = rowSource[j];
-          if (_config.header)
-            field = j >= _fields.length ? "__parsed_extra" : _fields[j];
-          if (_config.transform)
-            value = _config.transform(value, field);
-          value = parseDynamic(field, value);
-          if (field === "__parsed_extra") {
-            row[field] = row[field] || [];
-            row[field].push(value);
-          } else
-            row[field] = value;
-        }
-        if (_config.header) {
-          if (j > _fields.length)
-            addError(
-              "FieldMismatch",
-              "TooManyFields",
-              "Too many fields: expected " + _fields.length + " fields but parsed " + j,
-              _rowCounter + i
-            );
-          else if (j < _fields.length)
-            addError(
-              "FieldMismatch",
-              "TooFewFields",
-              "Too few fields: expected " + _fields.length + " fields but parsed " + j,
-              _rowCounter + i
-            );
-        }
-        return row;
+    applyHeaderAndDynamicTypingAndTransformation() {
+      if (!this._results || !this._results.data || !this._config.header && !this._config.dynamicTyping && !this._config.transform) {
+        return this._results;
       }
       var incrementBy = 1;
-      if (!_results.data[0] || Array.isArray(_results.data[0])) {
-        _results.data = _results.data.map(processRow);
-        incrementBy = _results.data.length;
-      } else
-        _results.data = processRow(_results.data, 0);
-      if (_config.header && _results.meta)
-        _results.meta.fields = _fields;
-      _rowCounter += incrementBy;
-      return _results;
-    }
-    function guessDelimiter(input, newline, skipEmptyLines, comments, delimitersToGuess) {
+      if (!this._results.data[0] || Array.isArray(this._results.data[0])) {
+        this._results.data = this._results.data.map(this.processRow.bind(this));
+        incrementBy = this._results.data.length;
+      } else {
+        this._results.data = this.processRow(this._results.data, 0);
+      }
+      if (this._config.header && this._results.meta)
+        this._results.meta.fields = this._fields;
+      this._rowCounter += incrementBy;
+      return this._results;
+    }
+    processRow(rowSource, i) {
+      var row = this._config.header ? {} : [];
+      var j;
+      for (j = 0; j < rowSource.length; j++) {
+        var field = j;
+        var value = rowSource[j];
+        if (this._config.header)
+          field = j >= this._fields.length ? "__parsed_extra" : this._fields[j];
+        if (this._config.transform)
+          value = this._config.transform(value, field);
+        value = this.parseDynamic(field, value);
+        if (field === "__parsed_extra") {
+          row[field] = row[field] || [];
+          row[field].push(value);
+        } else
+          row[field] = value;
+      }
+      if (this._config.header) {
+        if (j > this._fields.length)
+          this.addError(
+            "FieldMismatch",
+            "TooManyFields",
+            "Too many fields: expected " + this._fields.length + " fields but parsed " + j,
+            this._rowCounter + i
+          );
+        else if (j < this._fields.length)
+          this.addError(
+            "FieldMismatch",
+            "TooFewFields",
+            "Too few fields: expected " + this._fields.length + " fields but parsed " + j,
+            this._rowCounter + i
+          );
+      }
+      return row;
+    }
+    guessDelimiter(input, newline, skipEmptyLines, comments, delimitersToGuess) {
       var bestDelim, bestDelta, fieldCountPrevRow;
       delimitersToGuess = delimitersToGuess || [",", "	", "|", ";", Papa.RECORD_SEP, Papa.UNIT_SEP];
       for (var i = 0; i < delimitersToGuess.length; i++) {
@@ -1122,7 +1084,7 @@ var __exports__ = (() => {
           preview: 10
         }).parse(input);
         for (var j = 0; j < preview.data.length; j++) {
-          if (skipEmptyLines && testEmptyLine(preview.data[j])) {
+          if (skipEmptyLines && this.testEmptyLine(preview.data[j])) {
             emptyLinesCount++;
             continue;
           }
@@ -1143,36 +1105,36 @@ var __exports__ = (() => {
           bestDelim = delim;
         }
       }
-      _config.delimiter = bestDelim;
+      this._config.delimiter = bestDelim;
       return {
         successful: !!bestDelim,
         bestDelimiter: bestDelim
       };
     }
-    function guessLineEndings(input, quoteChar) {
-      input = input.substr(0, 1024 * 1024);
-      var re = new RegExp(escapeRegExp(quoteChar) + "([^]*?)" + escapeRegExp(quoteChar), "gm");
-      input = input.replace(re, "");
-      var r = input.split("\r");
-      var n = input.split("\n");
-      var nAppearsFirst = n.length > 1 && n[0].length < r[0].length;
-      if (r.length === 1 || nAppearsFirst)
-        return "\n";
-      var numWithN = 0;
-      for (var i = 0; i < r.length; i++) {
-        if (r[i][0] === "\n")
-          numWithN++;
-      }
-      return numWithN >= r.length / 2 ? "\r\n" : "\r";
-    }
-    function addError(type, code, msg, row) {
-      _results.errors.push({
+    addError(type, code, msg, row) {
+      this._results.errors.push({
         type,
         code,
         message: msg,
         row
       });
     }
+  };
+  function guessLineEndings(input, quoteChar) {
+    input = input.substr(0, 1024 * 1024);
+    var re = new RegExp(escapeRegExp(quoteChar) + "([^]*?)" + escapeRegExp(quoteChar), "gm");
+    input = input.replace(re, "");
+    var r = input.split("\r");
+    var n = input.split("\n");
+    var nAppearsFirst = n.length > 1 && n[0].length < r[0].length;
+    if (r.length === 1 || nAppearsFirst)
+      return "\n";
+    var numWithN = 0;
+    for (var i = 0; i < r.length; i++) {
+      if (r[i][0] === "\n")
+        numWithN++;
+    }
+    return numWithN >= r.length / 2 ? "\r\n" : "\r";
   }
   function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -1219,22 +1181,22 @@ var __exports__ = (() => {
       if (fastMode || fastMode !== false && input.indexOf(quoteChar) === -1) {
         var rows = input.split(newline);
         for (var i = 0; i < rows.length; i++) {
-          row = rows[i];
-          cursor += row.length;
+          const row2 = rows[i];
+          cursor += row2.length;
           if (i !== rows.length - 1)
             cursor += newline.length;
           else if (ignoreLastRow)
             return returnable();
-          if (comments && row.substr(0, commentsLen) === comments)
+          if (comments && row2.substr(0, commentsLen) === comments)
             continue;
           if (stepIsFunction) {
             data = [];
-            pushRow(row.split(delim));
+            pushRow(row2.split(delim));
             doStep();
             if (aborted)
               return returnable();
           } else
-            pushRow(row.split(delim));
+            pushRow(row2.split(delim));
           if (preview && i >= preview) {
             data = data.slice(0, preview);
             return returnable(true);
@@ -1425,14 +1387,47 @@ var __exports__ = (() => {
   function isFunction(func) {
     return typeof func === "function";
   }
+  var Papa = {
+    parse: CsvToJson,
+    unparse: JsonToCsv,
+    RECORD_SEP: String.fromCharCode(30),
+    UNIT_SEP: String.fromCharCode(31),
+    BYTE_ORDER_MARK,
+    BAD_DELIMITERS: ["\r", "\n", '"', BYTE_ORDER_MARK],
+    WORKERS_SUPPORTED: false,
+    // !IS_WORKER && !!globalThis.Worker
+    NODE_STREAM_INPUT: 1,
+    // Configurable chunk sizes for local and remote files, respectively
+    LocalChunkSize: 1024 * 1024 * 10,
+    // 10 M,
+    RemoteChunkSize: 1024 * 1024 * 5,
+    // 5 M,
+    DefaultDelimiter: ",",
+    // Used if not specified and detection fail,
+    // Exposed for testing and development only
+    Parser,
+    ParserHandle,
+    // BEGIN FORK
+    ChunkStreamer
+  };
+  var papaparse_default = Papa;
 
   // src/papaparse/async-iterator-streamer.ts
   var { ChunkStreamer: ChunkStreamer2 } = papaparse_default;
-  function AsyncIteratorStreamer(config) {
-    config = config || {};
-    ChunkStreamer2.call(this, config);
-    this.textDecoder = new TextDecoder(this._config.encoding);
-    this.stream = async function(asyncIterator) {
+  var AsyncIteratorStreamer = class extends ChunkStreamer2 {
+    textDecoder = new TextDecoder(this._config.encoding);
+    constructor(config = {}) {
+      super(config);
+    }
+    // Implement ChunkStreamer base class methods
+    // this.pause = function() {
+    //   ChunkStreamer.prototype.pause.apply(this, arguments);
+    // };
+    // this.resume = function() {
+    //   ChunkStreamer.prototype.resume.apply(this, arguments);
+    //   this._input.resume();
+    // };
+    async stream(asyncIterator) {
       this._input = asyncIterator;
       try {
         for await (const chunk of asyncIterator) {
@@ -1443,15 +1438,14 @@ var __exports__ = (() => {
       } catch (error) {
         this._sendError(error);
       }
-    };
-    this._nextChunk = function nextChunk() {
-    };
-    this.getStringChunk = function(chunk) {
+    }
+    _nextChunk() {
+    }
+    // HELPER METHODS
+    getStringChunk(chunk) {
       return typeof chunk === "string" ? chunk : this.textDecoder.decode(chunk, { stream: true });
-    };
-  }
-  AsyncIteratorStreamer.prototype = Object.create(ChunkStreamer2.prototype);
-  AsyncIteratorStreamer.prototype.constructor = AsyncIteratorStreamer;
+    }
+  };
 
   // src/csv-loader.ts
   var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
@@ -1624,7 +1618,6 @@ var __exports__ = (() => {
   }
   function readFirstRow(csvText) {
     const result = papaparse_default.parse(csvText, {
-      download: false,
       dynamicTyping: true,
       preview: 1
     });