@loaders.gl/csv 4.3.1 → 4.4.0-alpha.1

package/dist/index.cjs

@@ -20,149 +20,40 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  CSVArrowLoader: () => CSVArrowLoader,
   CSVLoader: () => CSVLoader,
   CSVWriter: () => CSVWriter
 });
 module.exports = __toCommonJS(dist_exports);
 
 // dist/csv-loader.js
-var import_schema = require("@loaders.gl/schema");
+var import_loader_utils = require("@loaders.gl/loader-utils");
+var import_schema_utils = require("@loaders.gl/schema-utils");
 
-// dist/papaparse/papaparse.js
+// dist/papaparse/papa-constants.js
 var BYTE_ORDER_MARK = "\uFEFF";
+var Papa = {
+  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,
+};
+
+// dist/papaparse/papa-parser.js
 function CsvToJson(_input, _config = {}, Streamer = StringStreamer) {
-  _config = _config || {};
-  var dynamicTyping = _config.dynamicTyping || false;
-  if (isFunction(dynamicTyping)) {
-    _config.dynamicTypingFunction = dynamicTyping;
-    dynamicTyping = {};
-  }
-  _config.dynamicTyping = dynamicTyping;
-  _config.transform = isFunction(_config.transform) ? _config.transform : false;
-  var streamer = new Streamer(_config);
+  const streamer = new Streamer(_config);
   return streamer.stream(_input);
 }
-function JsonToCsv(_input, _config) {
-  var _quotes = false;
-  var _writeHeader = true;
-  var _delimiter = ",";
-  var _newline = "\r\n";
-  var _quoteChar = '"';
-  var _escapedQuote = _quoteChar + _quoteChar;
-  var _skipEmptyLines = false;
-  var _columns = null;
-  unpackConfig();
-  var quoteCharRegex = new RegExp(escapeRegExp(_quoteChar), "g");
-  if (typeof _input === "string")
-    _input = JSON.parse(_input);
-  if (Array.isArray(_input)) {
-    if (!_input.length || Array.isArray(_input[0]))
-      return serialize(null, _input, _skipEmptyLines);
-    else if (typeof _input[0] === "object")
-      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);
-    if (Array.isArray(_input.data)) {
-      if (!_input.fields)
-        _input.fields = _input.meta && _input.meta.fields;
-      if (!_input.fields)
-        _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];
-    }
-    return serialize(_input.fields || [], _input.data || [], _skipEmptyLines);
-  }
-  throw new Error("Unable to serialize unrecognized input");
-  function unpackConfig() {
-    if (typeof _config !== "object")
-      return;
-    if (typeof _config.delimiter === "string" && !Papa.BAD_DELIMITERS.filter(function(value) {
-      return _config.delimiter.indexOf(value) !== -1;
-    }).length) {
-      _delimiter = _config.delimiter;
-    }
-    if (typeof _config.quotes === "boolean" || Array.isArray(_config.quotes))
-      _quotes = _config.quotes;
-    if (typeof _config.skipEmptyLines === "boolean" || typeof _config.skipEmptyLines === "string")
-      _skipEmptyLines = _config.skipEmptyLines;
-    if (typeof _config.newline === "string")
-      _newline = _config.newline;
-    if (typeof _config.quoteChar === "string")
-      _quoteChar = _config.quoteChar;
-    if (typeof _config.header === "boolean")
-      _writeHeader = _config.header;
-    if (Array.isArray(_config.columns)) {
-      if (_config.columns.length === 0)
-        throw new Error("Option columns is empty");
-      _columns = _config.columns;
-    }
-    if (_config.escapeChar !== void 0) {
-      _escapedQuote = _config.escapeChar + _quoteChar;
-    }
-  }
-  function serialize(fields, data, skipEmptyLines) {
-    var csv = "";
-    if (typeof fields === "string")
-      fields = JSON.parse(fields);
-    if (typeof data === "string")
-      data = JSON.parse(data);
-    var hasHeader = Array.isArray(fields) && fields.length > 0;
-    var dataKeyedByField = !Array.isArray(data[0]);
-    if (hasHeader && _writeHeader) {
-      for (var i = 0; i < fields.length; i++) {
-        if (i > 0)
-          csv += _delimiter;
-        csv += safe(fields[i], i);
-      }
-      if (data.length > 0)
-        csv += _newline;
-    }
-    for (var row = 0; row < data.length; row++) {
-      var maxCol = hasHeader ? fields.length : data[row].length;
-      var emptyLine = false;
-      var nullLine = hasHeader ? Object.keys(data[row]).length === 0 : data[row].length === 0;
-      if (skipEmptyLines && !hasHeader) {
-        emptyLine = skipEmptyLines === "greedy" ? data[row].join("").trim() === "" : data[row].length === 1 && data[row][0].length === 0;
-      }
-      if (skipEmptyLines === "greedy" && hasHeader) {
-        var line = [];
-        for (var c = 0; c < maxCol; c++) {
-          var cx = dataKeyedByField ? fields[c] : c;
-          line.push(data[row][cx]);
-        }
-        emptyLine = line.join("").trim() === "";
-      }
-      if (!emptyLine) {
-        for (var col = 0; col < maxCol; col++) {
-          if (col > 0 && !nullLine)
-            csv += _delimiter;
-          var colIdx = hasHeader && dataKeyedByField ? fields[col] : col;
-          csv += safe(data[row][colIdx], col);
-        }
-        if (row < data.length - 1 && (!skipEmptyLines || maxCol > 0 && !nullLine)) {
-          csv += _newline;
-        }
-      }
-    }
-    return csv;
-  }
-  function safe(str, col) {
-    if (typeof str === "undefined" || str === null)
-      return "";
-    if (str.constructor === Date)
-      return JSON.stringify(str).slice(1, 25);
-    str = str.toString().replace(quoteCharRegex, _escapedQuote);
-    var needsQuotes = typeof _quotes === "boolean" && _quotes || Array.isArray(_quotes) && _quotes[col] || hasAny(str, Papa.BAD_DELIMITERS) || str.indexOf(_delimiter) > -1 || str.charAt(0) === " " || str.charAt(str.length - 1) === " ";
-    return needsQuotes ? _quoteChar + str + _quoteChar : str;
-  }
-  function hasAny(str, substrings) {
-    for (var i = 0; i < substrings.length; i++)
-      if (str.indexOf(substrings[i]) > -1)
-        return true;
-    return false;
-  }
-}
 var ChunkStreamer = class {
   _handle;
   _config;
@@ -180,7 +71,10 @@ var ChunkStreamer = class {
     meta: {}
   };
   constructor(config) {
-    var configCopy = { ...config };
+    const configCopy = { ...config };
+    if (configCopy.dynamicTypingFunction) {
+      configCopy.dynamicTyping = {};
+    }
     configCopy.chunkSize = parseInt(configCopy.chunkSize);
     if (!config.step && !config.chunk) {
       configCopy.chunkSize = null;
@@ -189,26 +83,27 @@ var ChunkStreamer = class {
     this._handle.streamer = this;
     this._config = configCopy;
   }
+  // eslint-disable-next-line complexity, max-statements
   parseChunk(chunk, isFakeChunk) {
     if (this.isFirstChunk && isFunction(this._config.beforeFirstChunk)) {
-      var modifiedChunk = this._config.beforeFirstChunk(chunk);
+      const modifiedChunk = this._config.beforeFirstChunk(chunk);
       if (modifiedChunk !== void 0)
         chunk = modifiedChunk;
     }
     this.isFirstChunk = false;
-    var aggregate = this._partialLine + chunk;
+    const aggregate = this._partialLine + chunk;
     this._partialLine = "";
-    var results = this._handle.parse(aggregate, this._baseIndex, !this._finished);
+    let results = this._handle.parse(aggregate, this._baseIndex, !this._finished);
     if (this._handle.paused() || this._handle.aborted())
       return;
-    var lastIndex = results.meta.cursor;
+    const lastIndex = results.meta.cursor;
     if (!this._finished) {
       this._partialLine = aggregate.substring(lastIndex - this._baseIndex);
       this._baseIndex = lastIndex;
     }
     if (results && results.data)
       this._rowCount += results.data.length;
-    var finishedIncludingPreview = this._finished || this._config.preview && this._rowCount >= this._config.preview;
+    const finishedIncludingPreview = this._finished || this._config.preview && this._rowCount >= this._config.preview;
     if (isFunction(this._config.chunk) && !isFakeChunk) {
       this._config.chunk(results, this._handle);
       if (this._handle.paused() || this._handle.aborted())
@@ -244,8 +139,8 @@ var StringStreamer = class extends ChunkStreamer {
   _nextChunk() {
     if (this._finished)
       return;
-    var size = this._config.chunkSize;
-    var chunk = size ? this.remaining.substr(0, size) : this.remaining;
+    const size = this._config.chunkSize;
+    const chunk = size ? this.remaining.substr(0, size) : this.remaining;
     this.remaining = size ? this.remaining.substr(size) : "";
     this._finished = !this.remaining;
     return this.parseChunk(chunk);
@@ -279,7 +174,7 @@ var ParserHandle = class {
   };
   constructor(_config) {
     if (isFunction(_config.step)) {
-      var userStep = _config.step;
+      const userStep = _config.step;
       _config.step = (results) => {
         this._results = results;
         if (this.needsHeaderRow()) {
@@ -305,12 +200,12 @@ var ParserHandle = class {
    * when an input comes in multiple chunks, like from a file.
    */
   parse(input, baseIndex, ignoreLastRow) {
-    var quoteChar = this._config.quoteChar || '"';
+    const 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);
+      const 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 {
@@ -322,7 +217,7 @@ var ParserHandle = class {
       this._config.delimiter = this._config.delimiter(input);
       this._results.meta.delimiter = this._config.delimiter;
     }
-    var parserConfig = copy(this._config);
+    const parserConfig = copy(this._config);
     if (this._config.preview && this._config.header)
       parserConfig.preview++;
     this._input = input;
@@ -360,11 +255,11 @@ var ParserHandle = class {
   }
   processResults() {
     if (this._results && this._delimiterError) {
-      this.addError("Delimiter", "UndetectableDelimiter", "Unable to auto-detect delimiting character; defaulted to '" + Papa.DefaultDelimiter + "'");
+      this.addError("Delimiter", "UndetectableDelimiter", `Unable to auto-detect delimiting character; defaulted to '${Papa.DefaultDelimiter}'`);
       this._delimiterError = false;
     }
     if (this._config.skipEmptyLines) {
-      for (var i = 0; i < this._results.data.length; i++)
+      for (let i = 0; i < this._results.data.length; i++)
         if (this.testEmptyLine(this._results.data[i]))
           this._results.data.splice(i--, 1);
     }
@@ -385,7 +280,7 @@ var ParserHandle = class {
       this._fields.push(header);
     };
     if (Array.isArray(this._results.data[0])) {
-      for (var i = 0; this.needsHeaderRow() && i < this._results.data.length; i++)
+      for (let i = 0; this.needsHeaderRow() && i < this._results.data.length; i++)
         this._results.data[i].forEach(addHeder);
       this._results.data.splice(0, 1);
     } else {
@@ -393,10 +288,11 @@ var ParserHandle = class {
     }
   }
   shouldApplyDynamicTyping(field) {
-    if (this._config.dynamicTypingFunction && this._config.dynamicTyping[field] === void 0) {
+    var _a, _b;
+    if (this._config.dynamicTypingFunction && ((_a = this._config.dynamicTyping) == null ? void 0 : _a[field]) === void 0) {
       this._config.dynamicTyping[field] = this._config.dynamicTypingFunction(field);
     }
-    return (this._config.dynamicTyping[field] || this._config.dynamicTyping) === true;
+    return (((_b = this._config.dynamicTyping) == null ? void 0 : _b[field]) || this._config.dynamicTyping) === true;
   }
   parseDynamic(field, value) {
     if (this.shouldApplyDynamicTyping(field)) {
@@ -408,8 +304,7 @@ var ParserHandle = class {
         return parseFloat(value);
       else if (ISO_DATE.test(value))
         return new Date(value);
-      else
-        return value === "" ? null : value;
+      return value === "" ? null : value;
     }
     return value;
   }
@@ -417,7 +312,7 @@ var ParserHandle = class {
     if (!this._results || !this._results.data || !this._config.header && !this._config.dynamicTyping && !this._config.transform) {
       return this._results;
     }
-    var incrementBy = 1;
+    let incrementBy = 1;
     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;
@@ -430,11 +325,11 @@ var ParserHandle = class {
     return this._results;
   }
   processRow(rowSource, i) {
-    var row = this._config.header ? {} : [];
-    var j;
+    const row = this._config.header ? {} : [];
+    let j;
     for (j = 0; j < rowSource.length; j++) {
-      var field = j;
-      var value = rowSource[j];
+      let field = j;
+      let value = rowSource[j];
       if (this._config.header)
         field = j >= this._fields.length ? "__parsed_extra" : this._fields[j];
       if (this._config.transform)
@@ -448,31 +343,36 @@ var ParserHandle = class {
     }
     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);
+        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);
+        this.addError("FieldMismatch", "TooFewFields", `Too few fields: expected ${this._fields.length} fields but parsed ${j}`, this._rowCounter + i);
     }
     return row;
   }
+  // eslint-disable-next-line complexity, max-statements
   guessDelimiter(input, newline, skipEmptyLines, comments, delimitersToGuess) {
-    var bestDelim, bestDelta, fieldCountPrevRow;
+    let bestDelim;
+    let bestDelta;
+    let fieldCountPrevRow;
     delimitersToGuess = delimitersToGuess || [",", "	", "|", ";", Papa.RECORD_SEP, Papa.UNIT_SEP];
-    for (var i = 0; i < delimitersToGuess.length; i++) {
-      var delim = delimitersToGuess[i];
-      var delta = 0, avgFieldCount = 0, emptyLinesCount = 0;
+    for (let i = 0; i < delimitersToGuess.length; i++) {
+      const delim = delimitersToGuess[i];
+      let avgFieldCount = 0;
+      let delta = 0;
+      let emptyLinesCount = 0;
       fieldCountPrevRow = void 0;
-      var preview = new Parser({
+      const preview = new Parser({
         comments,
         delimiter: delim,
         newline,
         preview: 10
       }).parse(input);
-      for (var j = 0; j < preview.data.length; j++) {
+      for (let j = 0; j < preview.data.length; j++) {
         if (skipEmptyLines && this.testEmptyLine(preview.data[j])) {
           emptyLinesCount++;
           continue;
         }
-        var fieldCount = preview.data[j].length;
+        const fieldCount = preview.data[j].length;
         avgFieldCount += fieldCount;
         if (typeof fieldCountPrevRow === "undefined") {
           fieldCountPrevRow = 0;
@@ -491,7 +391,7 @@ var ParserHandle = class {
     }
     this._config.delimiter = bestDelim;
     return {
-      successful: !!bestDelim,
+      successful: Boolean(bestDelim),
       bestDelimiter: bestDelim
     };
   }
@@ -506,15 +406,15 @@ var ParserHandle = class {
 };
 function guessLineEndings(input, quoteChar) {
   input = input.substr(0, 1024 * 1024);
-  var re = new RegExp(escapeRegExp(quoteChar) + "([^]*?)" + escapeRegExp(quoteChar), "gm");
+  const 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;
+  const r = input.split("\r");
+  const n = input.split("\n");
+  const 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++) {
+  let numWithN = 0;
+  for (let i = 0; i < r.length; i++) {
     if (r[i][0] === "\n")
       numWithN++;
   }
@@ -523,48 +423,54 @@ function guessLineEndings(input, quoteChar) {
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function Parser(config) {
-  config = config || {};
-  var delim = config.delimiter;
-  var newline = config.newline;
-  var comments = config.comments;
-  var step = config.step;
-  var preview = config.preview;
-  var fastMode = config.fastMode;
-  var quoteChar;
+function Parser(config = {}) {
+  let delim = config.delimiter;
+  let newline = config.newline;
+  let comments = config.comments;
+  const step = config.step;
+  const preview = config.preview;
+  const fastMode = config.fastMode;
+  let quoteChar;
   if (config.quoteChar === void 0) {
     quoteChar = '"';
   } else {
     quoteChar = config.quoteChar;
   }
-  var escapeChar = quoteChar;
+  let escapeChar = quoteChar;
   if (config.escapeChar !== void 0) {
     escapeChar = config.escapeChar;
   }
   if (typeof delim !== "string" || Papa.BAD_DELIMITERS.indexOf(delim) > -1)
     delim = ",";
-  if (comments === delim)
+  if (comments === delim) {
     throw new Error("Comment character same as delimiter");
-  else if (comments === true)
+  } else if (comments === true) {
     comments = "#";
-  else if (typeof comments !== "string" || Papa.BAD_DELIMITERS.indexOf(comments) > -1)
+  } else if (typeof comments !== "string" || Papa.BAD_DELIMITERS.indexOf(comments) > -1) {
     comments = false;
+  }
   if (newline !== "\n" && newline !== "\r" && newline !== "\r\n")
     newline = "\n";
-  var cursor = 0;
-  var aborted = false;
+  let cursor = 0;
+  let aborted = false;
   this.parse = function(input, baseIndex, ignoreLastRow) {
     if (typeof input !== "string")
       throw new Error("Input must be a string");
-    var inputLen = input.length, delimLen = delim.length, newlineLen = newline.length, commentsLen = comments.length;
-    var stepIsFunction = isFunction(step);
+    const inputLen = input.length;
+    const delimLen = delim.length;
+    const newlineLen = newline.length;
+    const commentsLen = comments.length;
+    const stepIsFunction = isFunction(step);
     cursor = 0;
-    var data = [], errors = [], row = [], lastCursor = 0;
+    let data = [];
+    let errors = [];
+    let row = [];
+    let lastCursor = 0;
     if (!input)
       return returnable();
     if (fastMode || fastMode !== false && input.indexOf(quoteChar) === -1) {
-      var rows = input.split(newline);
-      for (var i = 0; i < rows.length; i++) {
+      const rows = input.split(newline);
+      for (let i = 0; i < rows.length; i++) {
         const row2 = rows[i];
         cursor += row2.length;
         if (i !== rows.length - 1)
@@ -588,10 +494,10 @@ function Parser(config) {
       }
       return returnable();
     }
-    var nextDelim = input.indexOf(delim, cursor);
-    var nextNewline = input.indexOf(newline, cursor);
-    var quoteCharRegex = new RegExp(escapeRegExp(escapeChar) + escapeRegExp(quoteChar), "g");
-    var quoteSearch;
+    let nextDelim = input.indexOf(delim, cursor);
+    let nextNewline = input.indexOf(newline, cursor);
+    const quoteCharRegex = new RegExp(escapeRegExp(escapeChar) + escapeRegExp(quoteChar), "g");
+    let quoteSearch;
     for (; ; ) {
       if (input[cursor] === quoteChar) {
         quoteSearch = cursor;
@@ -612,7 +518,7 @@ function Parser(config) {
             return finish();
           }
           if (quoteSearch === inputLen - 1) {
-            var value = input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar);
+            const value = input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar);
             return finish(value);
           }
           if (quoteChar === escapeChar && input[quoteSearch + 1] === escapeChar) {
@@ -622,8 +528,8 @@ function Parser(config) {
           if (quoteChar !== escapeChar && quoteSearch !== 0 && input[quoteSearch - 1] === escapeChar) {
             continue;
           }
-          var checkUpTo = nextNewline === -1 ? nextDelim : Math.min(nextDelim, nextNewline);
-          var spacesBetweenQuoteAndDelimiter = extraSpaces(checkUpTo);
+          const checkUpTo = nextNewline === -1 ? nextDelim : Math.min(nextDelim, nextNewline);
+          const spacesBetweenQuoteAndDelimiter = extraSpaces(checkUpTo);
           if (input[quoteSearch + 1 + spacesBetweenQuoteAndDelimiter] === delim) {
             row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
             cursor = quoteSearch + 1 + spacesBetweenQuoteAndDelimiter + delimLen;
@@ -638,7 +544,7 @@ function Parser(config) {
               return returnable(true);
             break;
           }
-          var spacesBetweenQuoteAndNewLine = extraSpaces(nextNewline);
+          const spacesBetweenQuoteAndNewLine = extraSpaces(nextNewline);
           if (input.substr(quoteSearch + 1 + spacesBetweenQuoteAndNewLine, newlineLen) === newline) {
             row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
             saveRow(quoteSearch + 1 + spacesBetweenQuoteAndNewLine + newlineLen);
@@ -706,21 +612,21 @@ function Parser(config) {
       lastCursor = cursor;
     }
     function extraSpaces(index) {
-      var spaceLength = 0;
+      let spaceLength = 0;
       if (index !== -1) {
-        var textBetweenClosingQuoteAndIndex = input.substring(quoteSearch + 1, index);
+        const textBetweenClosingQuoteAndIndex = input.substring(quoteSearch + 1, index);
         if (textBetweenClosingQuoteAndIndex && textBetweenClosingQuoteAndIndex.trim() === "") {
           spaceLength = textBetweenClosingQuoteAndIndex.length;
         }
       }
       return spaceLength;
     }
-    function finish(value2) {
+    function finish(value) {
       if (ignoreLastRow)
         return returnable();
-      if (typeof value2 === "undefined")
-        value2 = input.substr(cursor);
-      row.push(value2);
+      if (typeof value === "undefined")
+        value = input.substr(cursor);
+      row.push(value);
       cursor = inputLen;
       pushRow(row);
       if (stepIsFunction)
@@ -734,7 +640,7 @@ function Parser(config) {
       nextNewline = input.indexOf(newline, cursor);
     }
     function returnable(stopped, step2) {
-      var isStep = step2 || false;
+      const isStep = step2 || false;
       return {
         data: isStep ? data[0] : data,
         errors,
@@ -742,7 +648,7 @@ function Parser(config) {
           delimiter: delim,
           linebreak: newline,
           aborted,
-          truncated: !!stopped,
+          truncated: Boolean(stopped),
           cursor: lastCursor + (baseIndex || 0)
         }
       };
@@ -763,38 +669,157 @@ function Parser(config) {
 function copy(obj) {
   if (typeof obj !== "object" || obj === null)
     return obj;
-  var cpy = Array.isArray(obj) ? [] : {};
-  for (var key in obj)
+  const cpy = Array.isArray(obj) ? [] : {};
+  for (const key in obj)
     cpy[key] = copy(obj[key]);
   return cpy;
 }
 function isFunction(func) {
   return typeof func === "function";
 }
-var Papa = {
+
+// dist/papaparse/papa-writer.js
+function JsonToCsv(_input, _config = {}) {
+  let _quotes = false;
+  let _writeHeader = true;
+  let _delimiter = ",";
+  let _newline = "\r\n";
+  let _quoteChar = '"';
+  let _escapedQuote = _quoteChar + _quoteChar;
+  let _skipEmptyLines = false;
+  let _columns = null;
+  unpackConfig();
+  const quoteCharRegex = new RegExp(escapeRegExp2(_quoteChar), "g");
+  if (typeof _input === "string")
+    _input = JSON.parse(_input);
+  if (Array.isArray(_input)) {
+    if (!_input.length || Array.isArray(_input[0])) {
+      return serialize(null, _input, _skipEmptyLines);
+    } else if (typeof _input[0] === "object") {
+      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);
+    }
+    if (Array.isArray(_input.data)) {
+      if (!_input.fields) {
+        _input.fields = _input.meta && _input.meta.fields;
+      }
+      if (!_input.fields) {
+        _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];
+      }
+    }
+    return serialize(_input.fields || [], _input.data || [], _skipEmptyLines);
+  }
+  throw new Error("Unable to serialize unrecognized input");
+  function unpackConfig() {
+    if (typeof _config !== "object")
+      return;
+    if (typeof _config.delimiter === "string" && !Papa.BAD_DELIMITERS.filter(function(value) {
+      var _a;
+      return ((_a = _config.delimiter) == null ? void 0 : _a.indexOf(value)) !== -1;
+    }).length) {
+      _delimiter = _config.delimiter;
+    }
+    if (typeof _config.quotes === "boolean" || Array.isArray(_config.quotes))
+      _quotes = _config.quotes;
+    if (typeof _config.skipEmptyLines === "boolean" || _config.skipEmptyLines === "greedy")
+      _skipEmptyLines = _config.skipEmptyLines;
+    if (typeof _config.newline === "string")
+      _newline = _config.newline;
+    if (typeof _config.quoteChar === "string")
+      _quoteChar = _config.quoteChar;
+    if (typeof _config.header === "boolean")
+      _writeHeader = _config.header;
+    if (Array.isArray(_config.columns)) {
+      if (_config.columns.length === 0)
+        throw new Error("Option columns is empty");
+      _columns = _config.columns;
+    }
+    if (_config.escapeChar !== void 0) {
+      _escapedQuote = _config.escapeChar + _quoteChar;
+    }
+  }
+  function serialize(fields, data, skipEmptyLines) {
+    let csv = "";
+    if (typeof fields === "string")
+      fields = JSON.parse(fields);
+    if (typeof data === "string")
+      data = JSON.parse(data);
+    const hasHeader = Array.isArray(fields) && fields.length > 0;
+    const dataKeyedByField = !Array.isArray(data[0]);
+    if (hasHeader && _writeHeader) {
+      for (let i = 0; i < fields.length; i++) {
+        if (i > 0)
+          csv += _delimiter;
+        csv += safe(fields[i], i);
+      }
+      if (data.length > 0)
+        csv += _newline;
+    }
+    for (let row = 0; row < data.length; row++) {
+      const maxCol = hasHeader ? fields.length : data[row].length;
+      let emptyLine = false;
+      const nullLine = hasHeader ? Object.keys(data[row]).length === 0 : data[row].length === 0;
+      if (skipEmptyLines && !hasHeader) {
+        emptyLine = skipEmptyLines === "greedy" ? data[row].join("").trim() === "" : data[row].length === 1 && data[row][0].length === 0;
+      }
+      if (skipEmptyLines === "greedy" && hasHeader) {
+        const line = [];
+        for (let c = 0; c < maxCol; c++) {
+          const cx = dataKeyedByField ? fields[c] : c;
+          line.push(data[row][cx]);
+        }
+        emptyLine = line.join("").trim() === "";
+      }
+      if (!emptyLine) {
+        for (let col = 0; col < maxCol; col++) {
+          if (col > 0 && !nullLine)
+            csv += _delimiter;
+          const colIdx = hasHeader && dataKeyedByField ? fields[col] : col;
+          csv += safe(data[row][colIdx], col);
+        }
+        if (row < data.length - 1 && (!skipEmptyLines || maxCol > 0 && !nullLine)) {
+          csv += _newline;
+        }
+      }
+    }
+    return csv;
+  }
+  function safe(str, col) {
+    if (typeof str === "undefined" || str === null)
+      return "";
+    if (str.constructor === Date)
+      return JSON.stringify(str).slice(1, 25);
+    str = str.toString().replace(quoteCharRegex, _escapedQuote);
+    const needsQuotes = typeof _quotes === "boolean" && _quotes || Array.isArray(_quotes) && _quotes[col] || hasAny(str, Papa.BAD_DELIMITERS) || str.indexOf(_delimiter) > -1 || str.charAt(0) === " " || str.charAt(str.length - 1) === " ";
+    return needsQuotes ? _quoteChar + str + _quoteChar : str;
+  }
+  function hasAny(str, substrings) {
+    for (let i = 0; i < substrings.length; i++)
+      if (str.indexOf(substrings[i]) > -1)
+        return true;
+    return false;
+  }
+}
+function escapeRegExp2(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// dist/papaparse/papaparse.js
+var papaparse_default = {
+  ...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,
+  ChunkStreamer,
   // Exposed for testing and development only
   Parser,
-  ParserHandle,
-  // BEGIN FORK
-  ChunkStreamer
+  ParserHandle
 };
-var papaparse_default = Papa;
 
 // dist/papaparse/async-iterator-streamer.js
 var { ChunkStreamer: ChunkStreamer2 } = papaparse_default;
@@ -831,19 +856,24 @@ var AsyncIteratorStreamer = class extends ChunkStreamer2 {
   }
 };
 
+// dist/csv-format.js
+var CSVFormat = {
+  id: "csv",
+  module: "csv",
+  name: "CSV",
+  extensions: ["csv", "tsv", "dsv"],
+  mimeTypes: ["text/csv", "text/tab-separated-values", "text/dsv"],
+  category: "table"
+};
+
 // dist/csv-loader.js
-var VERSION = true ? "4.3.0" : "latest";
+var VERSION = true ? "4.4.0-alpha.0" : "latest";
 var DEFAULT_CSV_SHAPE = "object-row-table";
 var CSVLoader = {
+  ...CSVFormat,
   dataType: null,
   batchType: null,
-  id: "csv",
-  module: "csv",
-  name: "CSV",
   version: VERSION,
-  extensions: ["csv", "tsv", "dsv"],
-  mimeTypes: ["text/csv", "text/tab-separated-values", "text/dsv"],
-  category: "table",
   parse: async (arrayBuffer, options) => parseCSV(new TextDecoder().decode(arrayBuffer), options),
   parseText: (text, options) => parseCSV(text, options),
   parseInBatches: parseCSVInBatches,
@@ -890,20 +920,25 @@ async function parseCSV(csvText, options) {
   const rows = result.data;
   const headerRow = result.meta.fields || generateHeader(csvOptions.columnPrefix, firstRow.length);
   const shape = csvOptions.shape || DEFAULT_CSV_SHAPE;
+  let table;
   switch (shape) {
     case "object-row-table":
-      return {
+      table = {
         shape: "object-row-table",
-        data: rows.map((row) => Array.isArray(row) ? (0, import_schema.convertToObjectRow)(row, headerRow) : row)
+        data: rows.map((row) => Array.isArray(row) ? (0, import_schema_utils.convertToObjectRow)(row, headerRow) : row)
       };
+      break;
     case "array-row-table":
-      return {
+      table = {
         shape: "array-row-table",
-        data: rows.map((row) => Array.isArray(row) ? row : (0, import_schema.convertToArrayRow)(row, headerRow))
+        data: rows.map((row) => Array.isArray(row) ? row : (0, import_schema_utils.convertToArrayRow)(row, headerRow))
       };
+      break;
     default:
       throw new Error(shape);
   }
+  table.schema = (0, import_schema_utils.deduceTableSchema)(table);
+  return table;
 }
 function parseCSVInBatches(asyncIterator, options) {
   options = { ...options };
@@ -911,7 +946,7 @@ function parseCSVInBatches(asyncIterator, options) {
     options.batchSize = 4e3;
   }
   const csvOptions = { ...CSVLoader.options.csv, ...options == null ? void 0 : options.csv };
-  const asyncQueue = new import_schema.AsyncQueue();
+  const asyncQueue = new import_schema_utils.AsyncQueue();
   let isFirstRow = true;
   let headerRow = null;
   let tableBatchBuilder = null;
@@ -956,13 +991,13 @@ function parseCSVInBatches(asyncIterator, options) {
         if (!headerRow) {
           headerRow = generateHeader(csvOptions.columnPrefix, row.length);
         }
-        schema = deduceSchema(row, headerRow);
+        schema = deduceCSVSchema(row, headerRow);
       }
       if (csvOptions.optimizeMemoryUsage) {
         row = JSON.parse(JSON.stringify(row));
       }
       const shape = csvOptions.shape || DEFAULT_CSV_SHAPE;
-      tableBatchBuilder = tableBatchBuilder || new import_schema.TableBatchBuilder(
+      tableBatchBuilder = tableBatchBuilder || new import_schema_utils.TableBatchBuilder(
         // @ts-expect-error TODO this is not a proper schema
         schema,
         {
@@ -1027,26 +1062,37 @@ function generateHeader(columnPrefix, count = 0) {
   }
   return headers;
 }
-function deduceSchema(row, headerRow) {
-  const schema = headerRow ? {} : [];
+function deduceCSVSchema(row, headerRow) {
+  const fields = [];
   for (let i = 0; i < row.length; i++) {
     const columnName = headerRow && headerRow[i] || i;
     const value = row[i];
     switch (typeof value) {
       case "number":
+        fields.push({ name: String(columnName), type: "float64", nullable: true });
+        break;
       case "boolean":
-        schema[columnName] = { name: String(columnName), index: i, type: Float32Array };
+        fields.push({ name: String(columnName), type: "bool", nullable: true });
         break;
       case "string":
+        fields.push({ name: String(columnName), type: "utf8", nullable: true });
+        break;
       default:
-        schema[columnName] = { name: String(columnName), index: i, type: Array };
+        import_loader_utils.log.warn(`CSV: Unknown column type: ${typeof value}`)();
+        fields.push({ name: String(columnName), type: "utf8", nullable: true });
     }
   }
-  return schema;
+  return {
+    fields,
+    metadata: {
+      "loaders.gl#format": "csv",
+      "loaders.gl#loader": "CSVLoader"
+    }
+  };
 }
 
 // dist/lib/encoders/encode-csv.js
-var import_schema2 = require("@loaders.gl/schema");
+var import_schema_utils2 = require("@loaders.gl/schema-utils");
 var import_d3_dsv = require("d3-dsv");
 function encodeTableAsCSV(table, options = { csv: { useDisplayNames: true } }) {
   var _a, _b;
@@ -1058,9 +1104,9 @@ function encodeTableAsCSV(table, options = { csv: { useDisplayNames: true } }) {
     return useDisplayNames && typeof displayName === "string" ? displayName : f.name;
   });
   const formattedData = [columnNames];
-  for (const row of (0, import_schema2.makeArrayRowIterator)(table)) {
+  for (const row of (0, import_schema_utils2.makeArrayRowIterator)(table)) {
     const formattedRow = [];
-    for (let columnIndex = 0; columnIndex < (0, import_schema2.getTableNumCols)(table); ++columnIndex) {
+    for (let columnIndex = 0; columnIndex < (0, import_schema_utils2.getTableNumCols)(table); ++columnIndex) {
       const value = row[columnIndex];
       formattedRow[columnIndex] = preformatFieldValue(value);
     }
@@ -1083,12 +1129,8 @@ var preformatFieldValue = (value) => {
 
 // dist/csv-writer.js
 var CSVWriter = {
-  id: "csv",
+  ...CSVFormat,
   version: "latest",
-  module: "csv",
-  name: "CSV",
-  extensions: ["csv"],
-  mimeTypes: ["text/csv"],
   options: {
     csv: {
       useDisplayNames: false
@@ -1098,10 +1140,23 @@ var CSVWriter = {
   encode: async (table, options) => new TextEncoder().encode(encodeTableAsCSV(table, options)).buffer,
   encodeTextSync: (table, options) => encodeTableAsCSV(table, options)
 };
-/* @license
-Papa Parse
-v5.0.0-beta.0
-https://github.com/mholt/PapaParse
-License: MIT
-*/
+
+// dist/csv-arrow-loader.js
+var import_schema_utils3 = require("@loaders.gl/schema-utils");
+var CSVArrowLoader = {
+  ...CSVLoader,
+  dataType: null,
+  batchType: null,
+  parse: async (arrayBuffer, options) => parseCSVToArrow(new TextDecoder().decode(arrayBuffer), options),
+  parseText: (text, options) => parseCSVToArrow(text, options),
+  parseInBatches: parseCSVToArrowBatches
+};
+async function parseCSVToArrow(csvText, options) {
+  const table = await CSVLoader.parseText(csvText, options);
+  return (0, import_schema_utils3.convertTable)(table, "arrow-table");
+}
+function parseCSVToArrowBatches(asyncIterator, options) {
+  const tableIterator = CSVLoader.parseInBatches(asyncIterator, options);
+  return (0, import_schema_utils3.convertBatches)(tableIterator, "arrow-table");
+}
 //# sourceMappingURL=index.cjs.map