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

package/dist/index.cjs

@@ -30,32 +30,7 @@ var import_schema = require("@loaders.gl/schema");
 
 // dist/papaparse/papaparse.js
 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)) {
@@ -64,31 +39,7 @@ function CsvToJson(_input, _config, UserDefinedStreamer) {
   }
   _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) {
@@ -108,7 +59,7 @@ function JsonToCsv(_input, _config) {
     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);
@@ -116,7 +67,7 @@ function JsonToCsv(_input, _config) {
       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];
     }
@@ -150,14 +101,6 @@ function JsonToCsv(_input, _config) {
       _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 csv = "";
     if (typeof fields === "string")
@@ -220,24 +163,33 @@ function JsonToCsv(_input, _config) {
     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)
@@ -273,173 +225,181 @@ function ChunkStreamer(config) {
       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(input, _config.newline, _config.skipEmptyLines, _config.comments, _config.delimitersToGuess);
-      if (delimGuess.successful)
-        _config.delimiter = delimGuess.bestDelimiter;
-      else {
-        _delimiterError = true;
-        _config.delimiter = Papa.DefaultDelimiter;
+  /**
+   * 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, this._config.newline, this._config.skipEmptyLines, this._config.comments, this._config.delimitersToGuess);
+      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;
+    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;
   }
-  function processResults() {
-    if (_results && _delimiterError) {
-      addError("Delimiter", "UndetectableDelimiter", "Unable to auto-detect delimiting character; defaulted to '" + Papa.DefaultDelimiter + "'");
-      _delimiterError = false;
+  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 + "'");
+      this._delimiterError = false;
     }
-    if (_config.skipEmptyLines) {
-      for (var i = 0; i < _results.data.length; i++)
-        if (testEmptyLine(_results.data[i]))
-          _results.data.splice(i--, 1);
+    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 (needsHeaderRow())
-      fillHeaderFields();
-    return applyHeaderAndDynamicTypingAndTransformation();
+    if (this.needsHeaderRow()) {
+      this.fillHeaderFields();
+    }
+    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);
+    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);
     }
-    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);
+  shouldApplyDynamicTyping(field) {
+    if (this._config.dynamicTypingFunction && this._config.dynamicTyping[field] === void 0) {
+      this._config.dynamicTyping[field] = this._config.dynamicTypingFunction(field);
     }
-    return (_config.dynamicTyping[field] || _config.dynamicTyping) === true;
+    return (this._config.dynamicTyping[field] || this._config.dynamicTyping) === true;
   }
-  function parseDynamic(field, value) {
-    if (shouldApplyDynamicTyping(field)) {
+  parseDynamic(field, value) {
+    if (this.shouldApplyDynamicTyping(field)) {
       if (value === "true" || value === "TRUE")
         return true;
       else if (value === "false" || value === "FALSE")
@@ -453,46 +413,48 @@ function ParserHandle(_config) {
     }
     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;
+    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;
   }
-  function guessDelimiter(input, newline, skipEmptyLines, comments, delimitersToGuess) {
+  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++) {
@@ -506,7 +468,7 @@ function ParserHandle(_config) {
         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;
         }
@@ -527,36 +489,36 @@ function ParserHandle(_config) {
         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, "\\$&");
@@ -603,22 +565,22 @@ function Parser(config) {
     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);
@@ -809,14 +771,47 @@ function copy(obj) {
 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;
 
 // dist/papaparse/async-iterator-streamer.js
 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) {
@@ -827,18 +822,17 @@ function AsyncIteratorStreamer(config) {
     } 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;
+  }
+};
 
 // dist/csv-loader.js
-var VERSION = true ? "4.3.0-alpha.7" : "latest";
+var VERSION = true ? "4.3.0-alpha.8" : "latest";
 var DEFAULT_CSV_SHAPE = "object-row-table";
 var CSVLoader = {
   dataType: null,
@@ -1008,7 +1002,6 @@ function isHeaderRow(row) {
 }
 function readFirstRow(csvText) {
   const result = papaparse_default.parse(csvText, {
-    download: false,
     dynamicTyping: true,
     preview: 1
   });