@loaders.gl/csv 3.1.0-alpha.2 → 3.1.0-beta.1

package/{src/libs → dist/es5/papaparse}/papaparse.js

@@ -1,231 +1,129 @@
-// This is a fork of papaparse
-// https://github.com/mholt/PapaParse
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
 /* @license
 Papa Parse
 v5.0.0-beta.0
 https://github.com/mholt/PapaParse
 License: MIT
 */
-// FORK SUMMARY:
-// - Adopt ES6 exports
-// - Implement new AsyncIteratorStreamer
-// - Remove non Async Iterator streamers (can all be handled by new streamer)
-// - Remove unused Worker support (loaders.gl worker system used instead)
-// - Remove unused jQuery plugin support
-
-/* eslint-disable */
-// @ts-nocheck
-var global = (function() {
-  // alternative method, similar to `Function('return this')()`
-  // but without using `eval` (which is disabled when
-  // using Content Security Policy).
-
-  if (typeof self !== 'undefined') {
-    return self;
-  }
-  if (typeof window !== 'undefined') {
-    return window;
-  }
-  if (typeof global !== 'undefined') {
-    return global;
-  }
-
-  // When running tests none of the above have been defined
-  return {};
-})();
-
-var IS_PAPA_WORKER = false;
-
-var Papa = {};
-module.exports = Papa;
-Papa.parse = CsvToJson;
-Papa.unparse = JsonToCsv;
-
-Papa.RECORD_SEP = String.fromCharCode(30);
-Papa.UNIT_SEP = String.fromCharCode(31);
-Papa.BYTE_ORDER_MARK = '\ufeff';
-Papa.BAD_DELIMITERS = ['\r', '\n', '"', Papa.BYTE_ORDER_MARK];
-Papa.WORKERS_SUPPORTED = false; // !IS_WORKER && !!global.Worker;
-Papa.NODE_STREAM_INPUT = 1;
-
-// Configurable chunk sizes for local and remote files, respectively
-Papa.LocalChunkSize = 1024 * 1024 * 10; // 10 MB
-Papa.RemoteChunkSize = 1024 * 1024 * 5; // 5 MB
-Papa.DefaultDelimiter = ','; // Used if not specified and detection fails
-
-// Exposed for testing and development only
-Papa.Parser = Parser;
-Papa.ParserHandle = ParserHandle;
-
-// BEGIN FORK
-Papa.ChunkStreamer = ChunkStreamer;
-Papa.StringStreamer = StringStreamer;
-/*
-Papa.NetworkStreamer = NetworkStreamer;
-Papa.FileStreamer = FileStreamer;
-Papa.ReadableStreamStreamer = ReadableStreamStreamer;
-if (typeof PAPA_BROWSER_CONTEXT === 'undefined') {
-  Papa.DuplexStreamStreamer = DuplexStreamStreamer;
-}
-*/
-// END FORK
-
-// BEGIN FORK
-// Adds an argument to papa.parse
-// function CsvToJson(_input, _config)
-function CsvToJson(
-  _input,
-  _config,
-  UserDefinedStreamer // BEGIN FORK
-) {
+const BYTE_ORDER_MARK = '\ufeff';
+const 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,
+  NODE_STREAM_INPUT: 1,
+  LocalChunkSize: 1024 * 1024 * 10,
+  RemoteChunkSize: 1024 * 1024 * 5,
+  DefaultDelimiter: ',',
+  Parser: Parser,
+  ParserHandle: ParserHandle,
+  ChunkStreamer: ChunkStreamer,
+  StringStreamer: StringStreamer
+};
+var _default = Papa;
+exports.default = _default;
+
+function CsvToJson(_input, _config, UserDefinedStreamer) {
   _config = _config || {};
   var dynamicTyping = _config.dynamicTyping || false;
+
   if (isFunction(dynamicTyping)) {
     _config.dynamicTypingFunction = dynamicTyping;
-    // Will be filled on first row call
     dynamicTyping = {};
   }
-  _config.dynamicTyping = dynamicTyping;
 
+  _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; // prevent infinite loop
-
+    delete _config.worker;
     w.postMessage({
       input: _input,
       config: _config,
       workerId: w.id
     });
-
     return;
   }
 
   var streamer = null;
-  /*
-  if (_input === Papa.NODE_STREAM_INPUT && typeof PAPA_BROWSER_CONTEXT === 'undefined') {
-    // create a node Duplex stream for use
-    // with .pipe
-    streamer = new DuplexStreamStreamer(_config);
-    return streamer.getStream();
-  } else
-  */
+
   if (typeof _input === 'string') {
-    // if (_config.download) streamer = new NetworkStreamer(_config);
-    // else
     streamer = new StringStreamer(_config);
   }
-  /*
-  else if (_input.readable === true && isFunction(_input.read) && isFunction(_input.on)) {
-    streamer = new ReadableStreamStreamer(_config);
-  } else if ((global.File && _input instanceof File) || _input instanceof Object)
-    // ...Safari. (see issue #106)
-    streamer = new FileStreamer(_config);
-  */
-
-  // BEGIN FORK
+
   if (!streamer) {
     streamer = new UserDefinedStreamer(_config);
   }
-  // END FORK
 
   return streamer.stream(_input);
 }
 
 function JsonToCsv(_input, _config) {
-  // Default configuration
-
-  /** whether to surround every datum with quotes */
   var _quotes = false;
-
-  /** whether to write headers */
   var _writeHeader = true;
-
-  /** delimiting character(s) */
   var _delimiter = ',';
-
-  /** newline character(s) */
   var _newline = '\r\n';
-
-  /** quote character */
   var _quoteChar = '"';
 
-  /** escaped quote character, either "" or <config.escapeChar>" */
   var _escapedQuote = _quoteChar + _quoteChar;
 
-  /** whether to skip empty lines */
   var _skipEmptyLines = false;
-
-  /** the columns (keys) we expect when we unparse objects */
   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 || objectKeys(_input[0]), _input, _skipEmptyLines);
+    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);
   } 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 : objectKeys(_input.data[0]);
-
-      if (!Array.isArray(_input.data[0]) && typeof _input.data[0] !== 'object')
-        _input.data = [_input.data]; // handles input like [1,2,3] or ['asdf']
+      if (!_input.fields) _input.fields = Array.isArray(_input.data[0]) ? _input.fields : objectKeys(_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);
   }
 
-  // Default (any valid paths should return before this)
   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
-    ) {
+    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.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;
     }
 
@@ -234,93 +132,82 @@ function JsonToCsv(_input, _config) {
     }
   }
 
-  /** Turns an object's keys into an array */
   function objectKeys(obj) {
     if (typeof obj !== 'object') return [];
     var keys = [];
+
     for (var key in obj) keys.push(key);
+
     return keys;
   }
 
-  /** The double for loop that iterates the data and writes out a CSV string including header row */
   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 there a header row, write it first
     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;
     }
 
-    // Then write out the data
     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;
+        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))) {
+
+        if (row < data.length - 1 && (!skipEmptyLines || maxCol > 0 && !nullLine)) {
           csv += _newline;
         }
       }
     }
+
     return csv;
   }
 
-  /** Encloses a value around quotes if needed (makes a value safe for CSV insertion) */
   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) === ' ';
-
+    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;
   }
 }
 
-/** ChunkStreamer is the base prototype for various streamer implementations. */
 function ChunkStreamer(config) {
   this._handle = null;
   this._finished = false;
@@ -339,22 +226,20 @@ function ChunkStreamer(config) {
   };
   replaceConfig.call(this, config);
 
-  this.parseChunk = function(chunk, isFakeChunk) {
-    // First chunk pre-processing
+  this.parseChunk = function (chunk, isFakeChunk) {
     if (this.isFirstChunk && isFunction(this._config.beforeFirstChunk)) {
       var modifiedChunk = this._config.beforeFirstChunk(chunk);
+
       if (modifiedChunk !== undefined) chunk = modifiedChunk;
     }
-    this.isFirstChunk = false;
 
-    // Rejoin the line we likely just split in two by chunking the file
+    this.isFirstChunk = false;
     var aggregate = this._partialLine + chunk;
     this._partialLine = '';
 
     var results = this._handle.parse(aggregate, this._baseIndex, !this._finished);
 
     if (this._handle.paused() || this._handle.aborted()) return;
-
     var lastIndex = results.meta.cursor;
 
     if (!this._finished) {
@@ -363,18 +248,11 @@ function ChunkStreamer(config) {
     }
 
     if (results && results.data) this._rowCount += results.data.length;
+    var finishedIncludingPreview = this._finished || this._config.preview && this._rowCount >= this._config.preview;
 
-    var finishedIncludingPreview =
-      this._finished || (this._config.preview && this._rowCount >= this._config.preview);
-
-    if (IS_PAPA_WORKER) {
-      global.postMessage({
-        results: results,
-        workerId: Papa.WORKER_ID,
-        finished: finishedIncludingPreview
-      });
-    } else if (isFunction(this._config.chunk) && !isFakeChunk) {
+    if (isFunction(this._config.chunk) && !isFakeChunk) {
       this._config.chunk(results, this._handle);
+
       if (this._handle.paused() || this._handle.aborted()) return;
       results = undefined;
       this._completeResults = undefined;
@@ -386,52 +264,41 @@ function ChunkStreamer(config) {
       this._completeResults.meta = results.meta;
     }
 
-    if (
-      !this._completed &&
-      finishedIncludingPreview &&
-      isFunction(this._config.complete) &&
-      (!results || !results.meta.aborted)
-    ) {
+    if (!this._completed && finishedIncludingPreview && isFunction(this._config.complete) && (!results || !results.meta.aborted)) {
       this._config.complete(this._completeResults, this._input);
+
       this._completed = true;
     }
 
     if (!finishedIncludingPreview && (!results || !results.meta.paused)) this._nextChunk();
-
     return results;
   };
 
-  this._sendError = function(error) {
+  this._sendError = function (error) {
     if (isFunction(this._config.error)) this._config.error(error);
-    else if (IS_PAPA_WORKER && this._config.error) {
-      global.postMessage({
-        workerId: Papa.WORKER_ID,
-        error: error,
-        finished: false
-      });
-    }
   };
 
   function replaceConfig(config) {
-    // Deep-copy the config so we can edit it
     var configCopy = copy(config);
-    configCopy.chunkSize = parseInt(configCopy.chunkSize); // parseInt VERY important so we don't concatenate strings!
-    if (!config.step && !config.chunk) configCopy.chunkSize = null; // disable Range header if not streaming; bad values break IIS - see issue #196
+    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; // persist the copy to the caller
+    this._config = configCopy;
   }
 }
+
 function StringStreamer(config) {
   config = config || {};
   ChunkStreamer.call(this, config);
-
   var remaining;
-  this.stream = function(s) {
+
+  this.stream = function (s) {
     remaining = s;
     return this._nextChunk();
   };
-  this._nextChunk = function() {
+
+  this._nextChunk = function () {
     if (this._finished) return;
     var size = this._config.chunkSize;
     var chunk = size ? remaining.substr(0, size) : remaining;
@@ -440,26 +307,28 @@ function StringStreamer(config) {
     return this.parseChunk(chunk);
   };
 }
+
 StringStreamer.prototype = Object.create(StringStreamer.prototype);
 StringStreamer.prototype.constructor = StringStreamer;
 
-// Use one ParserHandle per entire CSV file or string
 function ParserHandle(_config) {
-  // One goal is to minimize the use of regular expressions...
   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; // Number of times step was called (number of rows parsed)
-  var _rowCounter = 0; // Number of rows that have been parsed so far
-  var _input; // The input being parsed
-  var _parser; // The core parser being used
-  var _paused = false; // Whether we are paused or not
-  var _aborted = false; // Whether the parser has aborted or not
-  var _delimiterError; // Temporary state between delimiter detection and processing results
-  var _fields = []; // Fields are from the header row of the input, if there is one
+  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
     data: [],
     errors: [],
     meta: {}
@@ -467,45 +336,27 @@ function ParserHandle(_config) {
 
   if (isFunction(_config.step)) {
     var userStep = _config.step;
-    _config.step = function(results) {
-      _results = results;
 
-      if (needsHeaderRow()) processResults();
-      // only call user's step function after header row
-      else {
-        processResults();
-
-        // It's possbile that this line was empty and there's no row here after all
-        if (!_results.data || _results.data.length === 0) return;
-
-        _stepCounter += results.data.length;
-        if (_config.preview && _stepCounter > _config.preview) _parser.abort();
-        else userStep(_results, self);
-      }
+    _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);
+        }
     };
   }
 
-  /**
-   * 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.
-   */
-  this.parse = function(input, baseIndex, ignoreLastRow) {
+  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; // add error after parsing (otherwise it would be overwritten)
+      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;
       }
       _results.meta.delimiter = _config.delimiter;
@@ -515,65 +366,68 @@ function ParserHandle(_config) {
     }
 
     var parserConfig = copy(_config);
-    if (_config.preview && _config.header) parserConfig.preview++; // to compensate for header row
-
+    if (_config.preview && _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}};
+    return _paused ? {
+      meta: {
+        paused: true
+      }
+    } : _results || {
+      meta: {
+        paused: false
+      }
+    };
   };
 
-  this.paused = function() {
+  this.paused = function () {
     return _paused;
   };
 
-  this.pause = function() {
+  this.pause = function () {
     _paused = true;
+
     _parser.abort();
+
     _input = _input.substr(_parser.getCharIndex());
   };
 
-  this.resume = function() {
+  this.resume = function () {
     _paused = false;
     self.streamer.parseChunk(_input, true);
   };
 
-  this.aborted = function() {
+  this.aborted = function () {
     return _aborted;
   };
 
-  this.abort = function() {
+  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;
+    return _config.skipEmptyLines === 'greedy' ? s.join('').trim() === '' : s.length === 1 && s[0].length === 0;
   }
 
   function processResults() {
     if (_results && _delimiterError) {
-      addError(
-        'Delimiter',
-        'UndetectableDelimiter',
-        "Unable to auto-detect delimiting character; defaulted to '" + Papa.DefaultDelimiter + "'"
-      );
+      addError('Delimiter', 'UndetectableDelimiter', "Unable to auto-detect delimiting character; defaulted to '" + Papa.DefaultDelimiter + "'");
       _delimiterError = false;
     }
 
     if (_config.skipEmptyLines) {
-      for (var i = 0; i < _results.data.length; i++)
-        if (testEmptyLine(_results.data[i])) _results.data.splice(i--, 1);
+      for (var i = 0; i < _results.data.length; i++) if (testEmptyLine(_results.data[i])) _results.data.splice(i--, 1);
     }
 
     if (needsHeaderRow()) fillHeaderFields();
-
     return applyHeaderAndDynamicTypingAndTransformation();
   }
 
@@ -591,50 +445,40 @@ function ParserHandle(_config) {
     }
 
     if (Array.isArray(_results.data[0])) {
-      for (var i = 0; needsHeaderRow() && i < _results.data.length; i++)
-        _results.data[i].forEach(addHeder);
+      for (var i = 0; needsHeaderRow() && i < _results.data.length; i++) _results.data[i].forEach(addHeder);
 
       _results.data.splice(0, 1);
-    }
-    // if _results.data[0] is not an array, we are in a step where _results.data is the row.
-    else _results.data.forEach(addHeder);
+    } else _results.data.forEach(addHeder);
   }
 
   function shouldApplyDynamicTyping(field) {
-    // Cache function values to avoid calling it for each row
     if (_config.dynamicTypingFunction && _config.dynamicTyping[field] === undefined) {
       _config.dynamicTyping[field] = _config.dynamicTypingFunction(field);
     }
+
     return (_config.dynamicTyping[field] || _config.dynamicTyping) === true;
   }
 
   function parseDynamic(field, value) {
     if (shouldApplyDynamicTyping(field)) {
-      if (value === 'true' || value === 'TRUE') return true;
-      else if (value === 'false' || value === 'FALSE') return false;
-      else if (FLOAT.test(value)) return parseFloat(value);
-      else if (ISO_DATE.test(value)) return new Date(value);
-      else return value === '' ? null : value;
+      if (value === 'true' || value === 'TRUE') return true;else if (value === 'false' || value === 'FALSE') return false;else if (FLOAT.test(value)) return parseFloat(value);else if (ISO_DATE.test(value)) return new Date(value);else return value === '' ? null : value;
     }
+
     return value;
   }
 
   function applyHeaderAndDynamicTypingAndTransformation() {
-    if (!_results || !_results.data || (!_config.header && !_config.dynamicTyping && !_config.transform))
-      return _results;
+    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') {
@@ -644,49 +488,34 @@ function ParserHandle(_config) {
       }
 
       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
-          );
+        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;
     }
 
     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) {
     var bestDelim, bestDelta, fieldCountPrevRow;
-
     delimitersToGuess = delimitersToGuess || [',', '\t', '|', ';', 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;
+          avgFieldCount = 0,
+          emptyLinesCount = 0;
       fieldCountPrevRow = undefined;
-
       var preview = new Parser({
         comments: comments,
         delimiter: delim,
@@ -699,6 +528,7 @@ function ParserHandle(_config) {
           emptyLinesCount++;
           continue;
         }
+
         var fieldCount = preview.data[j].length;
         avgFieldCount += fieldCount;
 
@@ -720,7 +550,6 @@ function ParserHandle(_config) {
     }
 
     _config.delimiter = bestDelim;
-
     return {
       successful: !!bestDelim,
       bestDelimiter: bestDelim
@@ -728,20 +557,15 @@ function ParserHandle(_config) {
   }
 
   function guessLineEndings(input, quoteChar) {
-    input = input.substr(0, 1024 * 1024); // max length 1 MB
-    // Replace all the text inside quotes
+    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++;
     }
@@ -759,14 +583,11 @@ function ParserHandle(_config) {
   }
 }
 
-/** https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions */
 function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-/** The core parser implements speedy and correct CSV parsing */
 function Parser(config) {
-  // Unpack the config object
   config = config || {};
   var delim = config.delimiter;
   var newline = config.newline;
@@ -775,73 +596,61 @@ function Parser(config) {
   var preview = config.preview;
   var fastMode = config.fastMode;
   var quoteChar;
-  /** Allows for no quoteChar by setting quoteChar to undefined in config */
+
   if (config.quoteChar === undefined) {
     quoteChar = '"';
   } else {
     quoteChar = config.quoteChar;
   }
+
   var escapeChar = quoteChar;
+
   if (config.escapeChar !== undefined) {
     escapeChar = config.escapeChar;
   }
 
-  // Delimiter must be valid
   if (typeof delim !== 'string' || Papa.BAD_DELIMITERS.indexOf(delim) > -1) delim = ',';
-
-  // Comment character must be valid
-  if (comments === delim) throw new Error('Comment character same as delimiter');
-  else if (comments === true) comments = '#';
-  else if (typeof comments !== 'string' || Papa.BAD_DELIMITERS.indexOf(comments) > -1)
-    comments = false;
-
-  // Newline must be valid: \r, \n, or \r\n
+  if (comments === delim) throw new Error('Comment character same as delimiter');else if (comments === true) comments = '#';else if (typeof comments !== 'string' || Papa.BAD_DELIMITERS.indexOf(comments) > -1) comments = false;
   if (newline !== '\n' && newline !== '\r' && newline !== '\r\n') newline = '\n';
-
-  // We're gonna need these at the Parser scope
   var cursor = 0;
   var aborted = false;
 
-  this.parse = function(input, baseIndex, ignoreLastRow) {
-    // For some reason, in Chrome, this speeds things up (!?)
+  this.parse = function (input, baseIndex, ignoreLastRow) {
     if (typeof input !== 'string') throw new Error('Input must be a string');
-
-    // We don't need to compute some of these every time parse() is called,
-    // but having them in a more local scope seems to perform better
     var inputLen = input.length,
-      delimLen = delim.length,
-      newlineLen = newline.length,
-      commentsLen = comments.length;
+        delimLen = delim.length,
+        newlineLen = newline.length,
+        commentsLen = comments.length;
     var stepIsFunction = isFunction(step);
-
-    // Establish starting state
     cursor = 0;
     var data = [],
-      errors = [],
-      row = [],
-      lastCursor = 0;
-
+        errors = [],
+        row = [],
+        lastCursor = 0;
     if (!input) return returnable();
 
-    if (fastMode || (fastMode !== false && input.indexOf(quoteChar) === -1)) {
+    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;
-        if (i !== rows.length - 1) cursor += newline.length;
-        else if (ignoreLastRow) return returnable();
+        if (i !== rows.length - 1) cursor += newline.length;else if (ignoreLastRow) return returnable();
         if (comments && row.substr(0, commentsLen) === comments) continue;
+
         if (stepIsFunction) {
           data = [];
           pushRow(row.split(delim));
           doStep();
           if (aborted) return returnable();
         } else pushRow(row.split(delim));
+
         if (preview && i >= preview) {
           data = data.slice(0, preview);
           return returnable(true);
         }
       }
+
       return returnable();
     }
 
@@ -850,62 +659,45 @@ function Parser(config) {
     var quoteCharRegex = new RegExp(escapeRegExp(escapeChar) + escapeRegExp(quoteChar), 'g');
     var quoteSearch;
 
-    // Parser loop
     for (;;) {
-      // Field has opening quote
       if (input[cursor] === quoteChar) {
-        // Start our search for the closing quote where the cursor is
         quoteSearch = cursor;
-
-        // Skip the opening quote
         cursor++;
 
         for (;;) {
-          // Find closing quote
           quoteSearch = input.indexOf(quoteChar, quoteSearch + 1);
 
-          //No other quotes are found - no other delimiters
           if (quoteSearch === -1) {
             if (!ignoreLastRow) {
-              // No closing quote... what a pity
               errors.push({
                 type: 'Quotes',
                 code: 'MissingQuotes',
                 message: 'Quoted field unterminated',
-                row: data.length, // row has yet to be inserted
+                row: data.length,
                 index: cursor
               });
             }
+
             return finish();
           }
 
-          // Closing quote at EOF
           if (quoteSearch === inputLen - 1) {
             var value = input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar);
             return finish(value);
           }
 
-          // If this quote is escaped, it's part of the data; skip it
-          // If the quote character is the escape character, then check if the next character is the escape character
           if (quoteChar === escapeChar && input[quoteSearch + 1] === escapeChar) {
             quoteSearch++;
             continue;
           }
 
-          // If the quote character is not the escape character, then check if the previous character was the escape character
-          if (
-            quoteChar !== escapeChar &&
-            quoteSearch !== 0 &&
-            input[quoteSearch - 1] === escapeChar
-          ) {
+          if (quoteChar !== escapeChar && quoteSearch !== 0 && input[quoteSearch - 1] === escapeChar) {
             continue;
           }
 
-          // Check up to nextDelim or nextNewline, whichever is closest
           var checkUpTo = nextNewline === -1 ? nextDelim : Math.min(nextDelim, nextNewline);
           var spacesBetweenQuoteAndDelimiter = extraSpaces(checkUpTo);
 
-          // Closing quote followed by delimiter or 'unnecessary spaces + delimiter'
           if (input[quoteSearch + 1 + spacesBetweenQuoteAndDelimiter] === delim) {
             row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
             cursor = quoteSearch + 1 + spacesBetweenQuoteAndDelimiter + delimLen;
@@ -918,19 +710,15 @@ function Parser(config) {
             }
 
             if (preview && data.length >= preview) return returnable(true);
-
             break;
           }
 
           var spacesBetweenQuoteAndNewLine = extraSpaces(nextNewline);
 
-          // Closing quote followed by newline or 'unnecessary spaces + newLine'
-          if (
-            input.substr(quoteSearch + 1 + spacesBetweenQuoteAndNewLine, newlineLen) === newline
-          ) {
+          if (input.substr(quoteSearch + 1 + spacesBetweenQuoteAndNewLine, newlineLen) === newline) {
             row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
             saveRow(quoteSearch + 1 + spacesBetweenQuoteAndNewLine + newlineLen);
-            nextDelim = input.indexOf(delim, cursor); // because we may have skipped the nextDelim in the quoted field
+            nextDelim = input.indexOf(delim, cursor);
 
             if (stepIsFunction) {
               doStep();
@@ -938,19 +726,16 @@ function Parser(config) {
             }
 
             if (preview && data.length >= preview) return returnable(true);
-
             break;
           }
 
-          // Checks for valid closing quotes are complete (escaped quotes or quote followed by EOF/delimiter/newline) -- assume these quotes are part of an invalid text string
           errors.push({
             type: 'Quotes',
             code: 'InvalidQuotes',
             message: 'Trailing quote on quoted field is malformed',
-            row: data.length, // row has yet to be inserted
+            row: data.length,
             index: cursor
           });
-
           quoteSearch++;
           continue;
         }
@@ -964,18 +749,14 @@ function Parser(config) {
         continue;
       }
 
-      // Comment found at start of new line
       if (comments && row.length === 0 && input.substr(cursor, commentsLen) === comments) {
-        if (nextNewline === -1)
-          // Comment ends at EOF
-          return returnable();
+        if (nextNewline === -1) return returnable();
         cursor = nextNewline + newlineLen;
         nextNewline = input.indexOf(newline, cursor);
         nextDelim = input.indexOf(delim, cursor);
         continue;
       }
 
-      // Next delimiter comes before next newline, so we've reached end of field
       if (nextDelim !== -1 && (nextDelim < nextNewline || nextNewline === -1)) {
         row.push(input.substring(cursor, nextDelim));
         cursor = nextDelim + delimLen;
@@ -983,7 +764,6 @@ function Parser(config) {
         continue;
       }
 
-      // End of row
       if (nextNewline !== -1) {
         row.push(input.substring(cursor, nextNewline));
         saveRow(nextNewline + newlineLen);
@@ -994,7 +774,6 @@ function Parser(config) {
         }
 
         if (preview && data.length >= preview) return returnable(true);
-
         continue;
       }
 
@@ -1008,41 +787,30 @@ function Parser(config) {
       lastCursor = cursor;
     }
 
-    /**
-     * checks if there are extra spaces after closing quote and given index without any text
-     * if Yes, returns the number of spaces
-     */
     function extraSpaces(index) {
       var spaceLength = 0;
+
       if (index !== -1) {
         var textBetweenClosingQuoteAndIndex = input.substring(quoteSearch + 1, index);
+
         if (textBetweenClosingQuoteAndIndex && textBetweenClosingQuoteAndIndex.trim() === '') {
           spaceLength = textBetweenClosingQuoteAndIndex.length;
         }
       }
+
       return spaceLength;
     }
 
-    /**
-     * Appends the remaining input from cursor to the end into
-     * row, saves the row, calls step, and returns the results.
-     */
     function finish(value) {
       if (ignoreLastRow) return returnable();
       if (typeof value === 'undefined') value = input.substr(cursor);
       row.push(value);
-      cursor = inputLen; // important in case parsing is paused
+      cursor = inputLen;
       pushRow(row);
       if (stepIsFunction) doStep();
       return returnable();
     }
 
-    /**
-     * Appends the current row to the results. It sets the cursor
-     * to newCursor and finds the nextNewline. The caller should
-     * take care to execute user's step function and check for
-     * preview and end parsing if necessary.
-     */
     function saveRow(newCursor) {
       cursor = newCursor;
       pushRow(row);
@@ -1050,7 +818,6 @@ function Parser(config) {
       nextNewline = input.indexOf(newline, cursor);
     }
 
-    /** Returns an object with the results, errors, and meta. */
     function returnable(stopped, step) {
       var isStep = step || false;
       return {
@@ -1066,7 +833,6 @@ function Parser(config) {
       };
     }
 
-    /** Executes the user's step function and resets data & errors. */
     function doStep() {
       step(returnable(undefined, true));
       data = [];
@@ -1074,13 +840,11 @@ function Parser(config) {
     }
   };
 
-  /** Sets the abort flag */
-  this.abort = function() {
+  this.abort = function () {
     aborted = true;
   };
 
-  /** Gets the cursor position */
-  this.getCharIndex = function() {
+  this.getCharIndex = function () {
     return cursor;
   };
 }
@@ -1089,14 +853,16 @@ function notImplemented() {
   throw new Error('Not implemented.');
 }
 
-/** Makes a deep copy of an array or object (mostly) */
 function copy(obj) {
   if (typeof obj !== 'object' || obj === null) return obj;
   var cpy = Array.isArray(obj) ? [] : {};
+
   for (var key in obj) cpy[key] = copy(obj[key]);
+
   return cpy;
 }
 
 function isFunction(func) {
   return typeof func === 'function';
 }
+//# sourceMappingURL=papaparse.js.map