@loaders.gl/csv 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/papaparse/papaparse.js

@@ -1,694 +1,933 @@
+// @ts-nocheck
+// This is a fork of papaparse
+// https://github.com/mholt/PapaParse
 /* @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 */
 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
+    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: Parser,
+    ParserHandle: ParserHandle,
+    // BEGIN FORK
+    ChunkStreamer: ChunkStreamer,
+    StringStreamer: StringStreamer
 };
 export default Papa;
-function CsvToJson(_input, _config, UserDefinedStreamer) {
-  _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;
-  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);
-  }
-  return streamer.stream(_input);
+/*
+Papa.NetworkStreamer = NetworkStreamer;
+Papa.FileStreamer = FileStreamer;
+Papa.ReadableStreamStreamer = ReadableStreamStreamer;
+if (typeof PAPA_BROWSER_CONTEXT === 'undefined') {
+  Papa.DuplexStreamStreamer = DuplexStreamStreamer;
 }
-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 || 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];
+*/
+// END FORK
+// BEGIN FORK
+// Adds an argument to papa.parse
+// function CsvToJson(_input, _config)
+function CsvToJson(_input, _config, UserDefinedStreamer // BEGIN FORK
+) {
+    _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.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
+        w.postMessage({
+            input: _input,
+            config: _config,
+            workerId: w.id
+        });
+        return;
     }
-    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;
+    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);
     }
-    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;
+    /*
+    else if (_input.readable === true && isFunction(_input.read) && isFunction(_input.on)) {
+      streamer = new ReadableStreamStreamer(_config);
+    } else if ((globalThis.File && _input instanceof File) || _input instanceof Object)
+      // ...Safari. (see issue #106)
+      streamer = new FileStreamer(_config);
+    */
+    // BEGIN FORK
+    if (!streamer) {
+        streamer = new UserDefinedStreamer(_config);
     }
-    if (_config.escapeChar !== undefined) {
-      _escapedQuote = _config.escapeChar + _quoteChar;
+    // 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);
     }
-  }
-  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') 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;
+    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']
+        }
+        return serialize(_input.fields || [], _input.data || [], _skipEmptyLines);
     }
-    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]);
+    // 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) {
+            _delimiter = _config.delimiter;
         }
-        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 (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 (row < data.length - 1 && (!skipEmptyLines || maxCol > 0 && !nullLine)) {
-          csv += _newline;
+        if (_config.escapeChar !== undefined) {
+            _escapedQuote = _config.escapeChar + _quoteChar;
         }
-      }
     }
-    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;
-  }
-}
-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 = {
-    data: [],
-    errors: [],
-    meta: {}
-  };
-  replaceConfig.call(this, config);
-  this.parseChunk = function (chunk, isFakeChunk) {
-    if (this.isFirstChunk && isFunction(this._config.beforeFirstChunk)) {
-      var modifiedChunk = this._config.beforeFirstChunk(chunk);
-      if (modifiedChunk !== undefined) chunk = modifiedChunk;
+    /** 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;
     }
-    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) {
-      this._partialLine = aggregate.substring(lastIndex - this._baseIndex);
-      this._baseIndex = lastIndex;
+    /** 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;
+            }
+            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;
     }
-    if (results && results.data) this._rowCount += results.data.length;
-    var 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()) return;
-      results = undefined;
-      this._completeResults = undefined;
+    /** 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) === ' ';
+        return needsQuotes ? _quoteChar + str + _quoteChar : str;
     }
-    if (!this._config.step && !this._config.chunk) {
-      this._completeResults.data = this._completeResults.data.concat(results.data);
-      this._completeResults.errors = this._completeResults.errors.concat(results.errors);
-      this._completeResults.meta = results.meta;
+    function hasAny(str, substrings) {
+        for (var i = 0; i < substrings.length; i++)
+            if (str.indexOf(substrings[i]) > -1)
+                return true;
+        return false;
     }
-    if (!this._completed && finishedIncludingPreview && isFunction(this._config.complete) && (!results || !results.meta.aborted)) {
-      this._config.complete(this._completeResults, this._input);
-      this._completed = true;
+}
+/** ChunkStreamer is the base prototype for various streamer implementations. */
+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 = {
+        data: [],
+        errors: [],
+        meta: {}
+    };
+    replaceConfig.call(this, config);
+    this.parseChunk = function (chunk, isFakeChunk) {
+        // First chunk pre-processing
+        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
+        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) {
+            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);
+        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;
+        }
+        if (!this._config.step && !this._config.chunk) {
+            this._completeResults.data = this._completeResults.data.concat(results.data);
+            this._completeResults.errors = this._completeResults.errors.concat(results.errors);
+            this._completeResults.meta = results.meta;
+        }
+        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) {
+        if (isFunction(this._config.error))
+            this._config.error(error);
+    };
+    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
+        this._handle = new ParserHandle(configCopy);
+        this._handle.streamer = this;
+        this._config = configCopy; // persist the copy to the caller
     }
-    if (!finishedIncludingPreview && (!results || !results.meta.paused)) this._nextChunk();
-    return results;
-  };
-  this._sendError = function (error) {
-    if (isFunction(this._config.error)) this._config.error(error);
-  };
-  function replaceConfig(config) {
-    var configCopy = copy(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;
-  }
 }
 function StringStreamer(config) {
-  config = config || {};
-  ChunkStreamer.call(this, config);
-  var remaining;
-  this.stream = function (s) {
-    remaining = s;
-    return this._nextChunk();
-  };
-  this._nextChunk = function () {
-    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;
-    return this.parseChunk(chunk);
-  };
+    config = config || {};
+    ChunkStreamer.call(this, config);
+    var remaining;
+    this.stream = function (s) {
+        remaining = s;
+        return this._nextChunk();
+    };
+    this._nextChunk = function () {
+        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;
+        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) {
-  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 = {
-    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);
-      }
+    // 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 _results = {
+        // The last results returned from the parser
+        data: [],
+        errors: [],
+        meta: {}
     };
-  }
-  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;
-      }
-      _results.meta.delimiter = _config.delimiter;
-    } else if (isFunction(_config.delimiter)) {
-      _config.delimiter = _config.delimiter(input);
-      _results.meta.delimiter = _config.delimiter;
+    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);
+            }
+        };
     }
-    var parserConfig = copy(_config);
-    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
-      }
+    /**
+     * 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) {
+        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)
+                _config.delimiter = Papa.DefaultDelimiter;
+            }
+            _results.meta.delimiter = _config.delimiter;
+        }
+        else if (isFunction(_config.delimiter)) {
+            _config.delimiter = _config.delimiter(input);
+            _results.meta.delimiter = _config.delimiter;
+        }
+        var parserConfig = copy(_config);
+        if (_config.preview && _config.header)
+            parserConfig.preview++; // to compensate for header row
+        _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.paused = function () {
-    return _paused;
-  };
-  this.pause = function () {
-    _paused = true;
-    _parser.abort();
-    _input = _input.substr(_parser.getCharIndex());
-  };
-  this.resume = function () {
-    _paused = false;
-    self.streamer.parseChunk(_input, true);
-  };
-  this.aborted = function () {
-    return _aborted;
-  };
-  this.abort = function () {
-    _aborted = true;
-    _parser.abort();
-    _results.meta.aborted = true;
-    if (isFunction(_config.complete)) _config.complete(_results);
-    _input = '';
-  };
-  function testEmptyLine(s) {
-    return _config.skipEmptyLines === 'greedy' ? s.join('').trim() === '' : s.length === 1 && s[0].length === 0;
-  }
-  function processResults() {
-    if (_results && _delimiterError) {
-      addError('Delimiter', 'UndetectableDelimiter', "Unable to auto-detect delimiting character; defaulted to '" + Papa.DefaultDelimiter + "'");
-      _delimiterError = false;
+    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;
     }
-    if (_config.skipEmptyLines) {
-      for (var i = 0; i < _results.data.length; i++) if (testEmptyLine(_results.data[i])) _results.data.splice(i--, 1);
+    function processResults() {
+        if (_results && _delimiterError) {
+            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);
+        }
+        if (needsHeaderRow())
+            fillHeaderFields();
+        return applyHeaderAndDynamicTypingAndTransformation();
     }
-    if (needsHeaderRow()) fillHeaderFields();
-    return applyHeaderAndDynamicTypingAndTransformation();
-  }
-  function needsHeaderRow() {
-    return _config.header && _fields.length === 0;
-  }
-  function fillHeaderFields() {
-    if (!_results) return;
-    function addHeder(header) {
-      if (isFunction(_config.transformHeader)) header = _config.transformHeader(header);
-      _fields.push(header);
+    function needsHeaderRow() {
+        return _config.header && _fields.length === 0;
     }
-    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] === undefined) {
-      _config.dynamicTyping[field] = _config.dynamicTypingFunction(field);
+    function fillHeaderFields() {
+        if (!_results)
+            return;
+        function addHeder(header) {
+            if (isFunction(_config.transformHeader))
+                header = _config.transformHeader(header);
+            _fields.push(header);
+        }
+        if (Array.isArray(_results.data[0])) {
+            for (var i = 0; needsHeaderRow() && i < _results.data.length; i++)
+                _results.data[i].forEach(addHeder);
+            _results.data.splice(0, 1);
+        }
+        // if _results.data[0] is not an array, we are in a step where _results.data is the row.
+        else
+            _results.data.forEach(addHeder);
     }
-    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;
+    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;
     }
-    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;
+    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;
+        }
+        return value;
     }
-    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;
-      fieldCountPrevRow = undefined;
-      var preview = new Parser({
-        comments: comments,
-        delimiter: delim,
-        newline: newline,
-        preview: 10
-      }).parse(input);
-      for (var j = 0; j < preview.data.length; j++) {
-        if (skipEmptyLines && testEmptyLine(preview.data[j])) {
-          emptyLinesCount++;
-          continue;
+    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;
         }
-        var fieldCount = preview.data[j].length;
-        avgFieldCount += fieldCount;
-        if (typeof fieldCountPrevRow === 'undefined') {
-          fieldCountPrevRow = 0;
-          continue;
-        } else if (fieldCount > 1) {
-          delta += Math.abs(fieldCount - fieldCountPrevRow);
-          fieldCountPrevRow = fieldCount;
+        var incrementBy = 1;
+        if (!_results.data[0] || Array.isArray(_results.data[0])) {
+            _results.data = _results.data.map(processRow);
+            incrementBy = _results.data.length;
         }
-      }
-      if (preview.data.length > 0) avgFieldCount /= preview.data.length - emptyLinesCount;
-      if ((typeof bestDelta === 'undefined' || delta > bestDelta) && avgFieldCount > 1.99) {
-        bestDelta = delta;
-        bestDelim = delim;
-      }
+        else
+            _results.data = processRow(_results.data, 0);
+        if (_config.header && _results.meta)
+            _results.meta.fields = _fields;
+        _rowCounter += incrementBy;
+        return _results;
     }
-    _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++;
+    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;
+            fieldCountPrevRow = undefined;
+            var preview = new Parser({
+                comments: comments,
+                delimiter: delim,
+                newline: newline,
+                preview: 10
+            }).parse(input);
+            for (var j = 0; j < preview.data.length; j++) {
+                if (skipEmptyLines && testEmptyLine(preview.data[j])) {
+                    emptyLinesCount++;
+                    continue;
+                }
+                var fieldCount = preview.data[j].length;
+                avgFieldCount += fieldCount;
+                if (typeof fieldCountPrevRow === 'undefined') {
+                    fieldCountPrevRow = 0;
+                    continue;
+                }
+                else if (fieldCount > 1) {
+                    delta += Math.abs(fieldCount - fieldCountPrevRow);
+                    fieldCountPrevRow = fieldCount;
+                }
+            }
+            if (preview.data.length > 0)
+                avgFieldCount /= preview.data.length - emptyLinesCount;
+            if ((typeof bestDelta === 'undefined' || delta > bestDelta) && avgFieldCount > 1.99) {
+                bestDelta = delta;
+                bestDelim = delim;
+            }
+        }
+        _config.delimiter = bestDelim;
+        return {
+            successful: !!bestDelim,
+            bestDelimiter: bestDelim
+        };
+    }
+    function guessLineEndings(input, quoteChar) {
+        input = input.substr(0, 1024 * 1024); // max length 1 MB
+        // Replace all the text inside quotes
+        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({
+            type: type,
+            code: code,
+            message: msg,
+            row: row
+        });
     }
-    return numWithN >= r.length / 2 ? '\r\n' : '\r';
-  }
-  function addError(type, code, msg, row) {
-    _results.errors.push({
-      type: type,
-      code: code,
-      message: msg,
-      row: row
-    });
-  }
 }
+/** https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions */
 function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
 }
+/** The core parser implements speedy and correct CSV parsing */
 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;
-  if (config.quoteChar === undefined) {
-    quoteChar = '"';
-  } else {
-    quoteChar = config.quoteChar;
-  }
-  var escapeChar = quoteChar;
-  if (config.escapeChar !== undefined) {
-    escapeChar = config.escapeChar;
-  }
-  if (typeof delim !== 'string' || Papa.BAD_DELIMITERS.indexOf(delim) > -1) delim = ',';
-  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';
-  var cursor = 0;
-  var 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);
-    cursor = 0;
-    var data = [],
-      errors = [],
-      row = [],
-      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++) {
-        row = rows[i];
-        cursor += row.length;
-        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();
+    // Unpack the config object
+    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;
+    /** 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;
     }
-    var nextDelim = input.indexOf(delim, cursor);
-    var nextNewline = input.indexOf(newline, cursor);
-    var quoteCharRegex = new RegExp(escapeRegExp(escapeChar) + escapeRegExp(quoteChar), 'g');
-    var quoteSearch;
-    for (;;) {
-      if (input[cursor] === quoteChar) {
-        quoteSearch = cursor;
-        cursor++;
+    // 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 (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 (!?)
+        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;
+        var stepIsFunction = isFunction(step);
+        // Establish starting state
+        cursor = 0;
+        var data = [], errors = [], row = [], 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++) {
+                row = rows[i];
+                cursor += row.length;
+                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();
+        }
+        var nextDelim = input.indexOf(delim, cursor);
+        var nextNewline = input.indexOf(newline, cursor);
+        var quoteCharRegex = new RegExp(escapeRegExp(escapeChar) + escapeRegExp(quoteChar), 'g');
+        var quoteSearch;
+        // Parser loop
         for (;;) {
-          quoteSearch = input.indexOf(quoteChar, quoteSearch + 1);
-          if (quoteSearch === -1) {
-            if (!ignoreLastRow) {
-              errors.push({
-                type: 'Quotes',
-                code: 'MissingQuotes',
-                message: 'Quoted field unterminated',
-                row: data.length,
-                index: cursor
-              });
+            // 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
+                                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) {
+                        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;
+                        nextDelim = input.indexOf(delim, cursor);
+                        nextNewline = input.indexOf(newline, cursor);
+                        if (stepIsFunction) {
+                            doStep();
+                            if (aborted)
+                                return returnable();
+                        }
+                        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) {
+                        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
+                        if (stepIsFunction) {
+                            doStep();
+                            if (aborted)
+                                return returnable();
+                        }
+                        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
+                        index: cursor
+                    });
+                    quoteSearch++;
+                    continue;
+                }
+                if (stepIsFunction) {
+                    doStep();
+                    if (aborted)
+                        return returnable();
+                }
+                if (preview && data.length >= preview)
+                    return returnable(true);
+                continue;
             }
-            return finish();
-          }
-          if (quoteSearch === inputLen - 1) {
-            var value = input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar);
-            return finish(value);
-          }
-          if (quoteChar === escapeChar && input[quoteSearch + 1] === escapeChar) {
-            quoteSearch++;
-            continue;
-          }
-          if (quoteChar !== escapeChar && quoteSearch !== 0 && input[quoteSearch - 1] === escapeChar) {
-            continue;
-          }
-          var checkUpTo = nextNewline === -1 ? nextDelim : Math.min(nextDelim, nextNewline);
-          var spacesBetweenQuoteAndDelimiter = extraSpaces(checkUpTo);
-          if (input[quoteSearch + 1 + spacesBetweenQuoteAndDelimiter] === delim) {
-            row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
-            cursor = quoteSearch + 1 + spacesBetweenQuoteAndDelimiter + delimLen;
-            nextDelim = input.indexOf(delim, cursor);
-            nextNewline = input.indexOf(newline, cursor);
-            if (stepIsFunction) {
-              doStep();
-              if (aborted) return returnable();
+            // 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();
+                cursor = nextNewline + newlineLen;
+                nextNewline = input.indexOf(newline, cursor);
+                nextDelim = input.indexOf(delim, cursor);
+                continue;
             }
-            if (preview && data.length >= preview) return returnable(true);
-            break;
-          }
-          var 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);
-            nextDelim = input.indexOf(delim, cursor);
-            if (stepIsFunction) {
-              doStep();
-              if (aborted) return returnable();
+            // 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;
+                nextDelim = input.indexOf(delim, cursor);
+                continue;
+            }
+            // End of row
+            if (nextNewline !== -1) {
+                row.push(input.substring(cursor, nextNewline));
+                saveRow(nextNewline + newlineLen);
+                if (stepIsFunction) {
+                    doStep();
+                    if (aborted)
+                        return returnable();
+                }
+                if (preview && data.length >= preview)
+                    return returnable(true);
+                continue;
             }
-            if (preview && data.length >= preview) return returnable(true);
             break;
-          }
-          errors.push({
-            type: 'Quotes',
-            code: 'InvalidQuotes',
-            message: 'Trailing quote on quoted field is malformed',
-            row: data.length,
-            index: cursor
-          });
-          quoteSearch++;
-          continue;
         }
-        if (stepIsFunction) {
-          doStep();
-          if (aborted) return returnable();
+        return finish();
+        function pushRow(row) {
+            data.push(row);
+            lastCursor = cursor;
         }
-        if (preview && data.length >= preview) return returnable(true);
-        continue;
-      }
-      if (comments && row.length === 0 && input.substr(cursor, commentsLen) === comments) {
-        if (nextNewline === -1) return returnable();
-        cursor = nextNewline + newlineLen;
-        nextNewline = input.indexOf(newline, cursor);
-        nextDelim = input.indexOf(delim, cursor);
-        continue;
-      }
-      if (nextDelim !== -1 && (nextDelim < nextNewline || nextNewline === -1)) {
-        row.push(input.substring(cursor, nextDelim));
-        cursor = nextDelim + delimLen;
-        nextDelim = input.indexOf(delim, cursor);
-        continue;
-      }
-      if (nextNewline !== -1) {
-        row.push(input.substring(cursor, nextNewline));
-        saveRow(nextNewline + newlineLen);
-        if (stepIsFunction) {
-          doStep();
-          if (aborted) return returnable();
+        /**
+         * 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;
         }
-        if (preview && data.length >= preview) return returnable(true);
-        continue;
-      }
-      break;
-    }
-    return finish();
-    function pushRow(row) {
-      data.push(row);
-      lastCursor = cursor;
-    }
-    function extraSpaces(index) {
-      var spaceLength = 0;
-      if (index !== -1) {
-        var textBetweenClosingQuoteAndIndex = input.substring(quoteSearch + 1, index);
-        if (textBetweenClosingQuoteAndIndex && textBetweenClosingQuoteAndIndex.trim() === '') {
-          spaceLength = textBetweenClosingQuoteAndIndex.length;
+        /**
+         * 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
+            pushRow(row);
+            if (stepIsFunction)
+                doStep();
+            return returnable();
         }
-      }
-      return spaceLength;
-    }
-    function finish(value) {
-      if (ignoreLastRow) return returnable();
-      if (typeof value === 'undefined') value = input.substr(cursor);
-      row.push(value);
-      cursor = inputLen;
-      pushRow(row);
-      if (stepIsFunction) doStep();
-      return returnable();
-    }
-    function saveRow(newCursor) {
-      cursor = newCursor;
-      pushRow(row);
-      row = [];
-      nextNewline = input.indexOf(newline, cursor);
-    }
-    function returnable(stopped, step) {
-      var isStep = step || false;
-      return {
-        data: isStep ? data[0] : data,
-        errors: errors,
-        meta: {
-          delimiter: delim,
-          linebreak: newline,
-          aborted: aborted,
-          truncated: !!stopped,
-          cursor: lastCursor + (baseIndex || 0)
+        /**
+         * 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);
+            row = [];
+            nextNewline = input.indexOf(newline, cursor);
         }
-      };
-    }
-    function doStep() {
-      step(returnable(undefined, true));
-      data = [];
-      errors = [];
-    }
-  };
-  this.abort = function () {
-    aborted = true;
-  };
-  this.getCharIndex = function () {
-    return cursor;
-  };
+        /** Returns an object with the results, errors, and meta. */
+        function returnable(stopped, step) {
+            var isStep = step || false;
+            return {
+                data: isStep ? data[0] : data,
+                errors: errors,
+                meta: {
+                    delimiter: delim,
+                    linebreak: newline,
+                    aborted: aborted,
+                    truncated: !!stopped,
+                    cursor: lastCursor + (baseIndex || 0)
+                }
+            };
+        }
+        /** Executes the user's step function and resets data & errors. */
+        function doStep() {
+            step(returnable(undefined, true));
+            data = [];
+            errors = [];
+        }
+    };
+    /** Sets the abort flag */
+    this.abort = function () {
+        aborted = true;
+    };
+    /** Gets the cursor position */
+    this.getCharIndex = function () {
+        return cursor;
+    };
 }
 function notImplemented() {
-  throw new Error('Not implemented.');
+    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;
+    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';
+    return typeof func === 'function';
 }
-//# sourceMappingURL=papaparse.js.map