@loaders.gl/csv 3.4.11 → 3.4.12

package/dist/es5/csv-loader.js

@@ -14,7 +14,7 @@ var _papaparse = _interopRequireDefault(require("./papaparse/papaparse"));
 var _asyncIteratorStreamer = _interopRequireDefault(require("./papaparse/async-iterator-streamer"));
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var VERSION = typeof "3.4.11" !== 'undefined' ? "3.4.11" : 'latest';
+var VERSION = typeof "3.4.12" !== 'undefined' ? "3.4.12" : 'latest';
 var DEFAULT_CSV_LOADER_OPTIONS = {
   csv: {
     shape: 'object-row-table',

package/dist/esm/csv-loader.js

@@ -1,7 +1,7 @@
 import { AsyncQueue, TableBatchBuilder, convertToArrayRow, convertToObjectRow } from '@loaders.gl/schema';
 import Papa from './papaparse/papaparse';
 import AsyncIteratorStreamer from './papaparse/async-iterator-streamer';
-const VERSION = typeof "3.4.11" !== 'undefined' ? "3.4.11" : 'latest';
+const VERSION = typeof "3.4.12" !== 'undefined' ? "3.4.12" : 'latest';
 const DEFAULT_CSV_LOADER_OPTIONS = {
   csv: {
     shape: 'object-row-table',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/csv",
-  "version": "3.4.11",
+  "version": "3.4.12",
   "description": "Framework-independent loader for CSV and DSV table formats",
   "license": "MIT",
   "publishConfig": {
@@ -30,11 +30,11 @@
     "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.4.11",
-    "@loaders.gl/schema": "3.4.11"
+    "@loaders.gl/loader-utils": "3.4.12",
+    "@loaders.gl/schema": "3.4.12"
   },
   "devDependencies": {
     "d3-dsv": "^1.2.0"
   },
-  "gitHead": "2b8d490d2372e70dd89eef8f6b215a5205c16621"
+  "gitHead": "85254762ae3082f608a863291deef09f2b40c6cf"
 }

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/csv-loader.js

@@ -1,267 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckCSVLoader = exports.CSVLoader = void 0;
-const schema_1 = require("@loaders.gl/schema");
-const papaparse_1 = __importDefault(require("./papaparse/papaparse"));
-const async_iterator_streamer_1 = __importDefault(require("./papaparse/async-iterator-streamer"));
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
-const DEFAULT_CSV_LOADER_OPTIONS = {
-    csv: {
-        shape: 'object-row-table',
-        optimizeMemoryUsage: false,
-        // CSV options
-        header: 'auto',
-        columnPrefix: 'column',
-        // delimiter: auto
-        // newline: auto
-        quoteChar: '"',
-        escapeChar: '"',
-        dynamicTyping: true,
-        comments: false,
-        skipEmptyLines: true,
-        // transform: null?
-        delimitersToGuess: [',', '\t', '|', ';']
-        // fastMode: auto
-    }
-};
-exports.CSVLoader = {
-    id: 'csv',
-    module: 'csv',
-    name: 'CSV',
-    version: VERSION,
-    extensions: ['csv', 'tsv', 'dsv'],
-    mimeTypes: ['text/csv', 'text/tab-separated-values', 'text/dsv'],
-    category: 'table',
-    parse: async (arrayBuffer, options) => parseCSV(new TextDecoder().decode(arrayBuffer), options),
-    parseText: (text, options) => parseCSV(text, options),
-    parseInBatches: parseCSVInBatches,
-    // @ts-ignore
-    // testText: null,
-    options: DEFAULT_CSV_LOADER_OPTIONS
-};
-async function parseCSV(csvText, options) {
-    // Apps can call the parse method directly, we so apply default options here
-    const csvOptions = { ...DEFAULT_CSV_LOADER_OPTIONS.csv, ...options?.csv };
-    const firstRow = readFirstRow(csvText);
-    const header = csvOptions.header === 'auto' ? isHeaderRow(firstRow) : Boolean(csvOptions.header);
-    const parseWithHeader = header;
-    const papaparseConfig = {
-        // dynamicTyping: true,
-        ...csvOptions,
-        header: parseWithHeader,
-        download: false,
-        transformHeader: parseWithHeader ? duplicateColumnTransformer() : undefined,
-        error: (e) => {
-            throw new Error(e);
-        }
-    };
-    const result = papaparse_1.default.parse(csvText, papaparseConfig);
-    let { data: rows } = result;
-    const headerRow = result.meta.fields || generateHeader(csvOptions.columnPrefix, firstRow.length);
-    switch (csvOptions.shape) {
-        case 'object-row-table':
-            rows = rows.map((row) => (Array.isArray(row) ? (0, schema_1.convertToObjectRow)(row, headerRow) : row));
-            break;
-        case 'array-row-table':
-            rows = rows.map((row) => (Array.isArray(row) ? row : (0, schema_1.convertToArrayRow)(row, headerRow)));
-            break;
-        default:
-    }
-    /*
-    if (!header && shape === 'object-row-table') {
-      // If the dataset has no header, transform the array result into an object shape with an
-      // autogenerated header
-      return result.data.map((row) =>
-        row.reduce((acc, value, i) => {
-          acc[headerRow[i]] = value;
-          return acc;
-        }, {})
-      );
-    }
-    */
-    return rows;
-}
-// TODO - support batch size 0 = no batching/single batch?
-function parseCSVInBatches(asyncIterator, options) {
-    // Papaparse does not support standard batch size handling
-    // TODO - investigate papaparse chunks mode
-    options = { ...options };
-    if (options.batchSize === 'auto') {
-        options.batchSize = 4000;
-    }
-    // Apps can call the parse method directly, we so apply default options here
-    const csvOptions = { ...DEFAULT_CSV_LOADER_OPTIONS.csv, ...options?.csv };
-    const asyncQueue = new schema_1.AsyncQueue();
-    let isFirstRow = true;
-    let headerRow = null;
-    let tableBatchBuilder = null;
-    let schema = null;
-    const config = {
-        // dynamicTyping: true, // Convert numbers and boolean values in rows from strings,
-        ...csvOptions,
-        header: false,
-        download: false,
-        // chunkSize is set to 5MB explicitly (same as Papaparse default) due to a bug where the
-        // streaming parser gets stuck if skipEmptyLines and a step callback are both supplied.
-        // See https://github.com/mholt/PapaParse/issues/465
-        chunkSize: 1024 * 1024 * 5,
-        // skipEmptyLines is set to a boolean value if supplied. Greedy is set to true
-        // skipEmptyLines is handled manually given two bugs where the streaming parser gets stuck if
-        // both of the skipEmptyLines and step callback options are provided:
-        // - true doesn't work unless chunkSize is set: https://github.com/mholt/PapaParse/issues/465
-        // - greedy doesn't work: https://github.com/mholt/PapaParse/issues/825
-        skipEmptyLines: false,
-        // step is called on every row
-        // eslint-disable-next-line complexity
-        step(results) {
-            let row = results.data;
-            if (csvOptions.skipEmptyLines) {
-                // Manually reject lines that are empty
-                const collapsedRow = row.flat().join('').trim();
-                if (collapsedRow === '') {
-                    return;
-                }
-            }
-            const bytesUsed = results.meta.cursor;
-            // Check if we need to save a header row
-            if (isFirstRow && !headerRow) {
-                // Auto detects or can be forced with csvOptions.header
-                const header = csvOptions.header === 'auto' ? isHeaderRow(row) : Boolean(csvOptions.header);
-                if (header) {
-                    headerRow = row.map(duplicateColumnTransformer());
-                    return;
-                }
-            }
-            // If first data row, we can deduce the schema
-            if (isFirstRow) {
-                isFirstRow = false;
-                if (!headerRow) {
-                    headerRow = generateHeader(csvOptions.columnPrefix, row.length);
-                }
-                schema = deduceSchema(row, headerRow);
-            }
-            if (csvOptions.optimizeMemoryUsage) {
-                // A workaround to allocate new strings and don't retain pointers to original strings.
-                // https://bugs.chromium.org/p/v8/issues/detail?id=2869
-                row = JSON.parse(JSON.stringify(row));
-            }
-            // Add the row
-            tableBatchBuilder =
-                tableBatchBuilder ||
-                    new schema_1.TableBatchBuilder(schema, {
-                        // @ts-expect-error
-                        shape: csvOptions.shape || 'array-row-table',
-                        ...options
-                    });
-            try {
-                tableBatchBuilder.addRow(row);
-                // If a batch has been completed, emit it
-                const batch = tableBatchBuilder && tableBatchBuilder.getFullBatch({ bytesUsed });
-                if (batch) {
-                    asyncQueue.enqueue(batch);
-                }
-            }
-            catch (error) {
-                asyncQueue.enqueue(error);
-            }
-        },
-        // complete is called when all rows have been read
-        complete(results) {
-            try {
-                const bytesUsed = results.meta.cursor;
-                // Ensure any final (partial) batch gets emitted
-                const batch = tableBatchBuilder && tableBatchBuilder.getFinalBatch({ bytesUsed });
-                if (batch) {
-                    asyncQueue.enqueue(batch);
-                }
-            }
-            catch (error) {
-                asyncQueue.enqueue(error);
-            }
-            asyncQueue.close();
-        }
-    };
-    papaparse_1.default.parse(asyncIterator, config, async_iterator_streamer_1.default);
-    // TODO - Does it matter if we return asyncIterable or asyncIterator
-    // return asyncQueue[Symbol.asyncIterator]();
-    return asyncQueue;
-}
-/**
- * Checks if a certain row is a header row
- * @param row the row to check
- * @returns true if the row looks like a header
- */
-function isHeaderRow(row) {
-    return row && row.every((value) => typeof value === 'string');
-}
-/**
- * Reads, parses, and returns the first row of a CSV text
- * @param csvText the csv text to parse
- * @returns the first row
- */
-function readFirstRow(csvText) {
-    const result = papaparse_1.default.parse(csvText, {
-        download: false,
-        dynamicTyping: true,
-        preview: 1
-    });
-    return result.data[0];
-}
-/**
- * Creates a transformer that renames duplicate columns. This is needed as Papaparse doesn't handle
- * duplicate header columns and would use the latest occurrence by default.
- * See the header option in https://www.papaparse.com/docs#config
- * @returns a transform function that returns sanitized names for duplicate fields
- */
-function duplicateColumnTransformer() {
-    const observedColumns = new Set();
-    return (col) => {
-        let colName = col;
-        let counter = 1;
-        while (observedColumns.has(colName)) {
-            colName = `${col}.${counter}`;
-            counter++;
-        }
-        observedColumns.add(colName);
-        return colName;
-    };
-}
-/**
- * Generates the header of a CSV given a prefix and a column count
- * @param columnPrefix the columnPrefix to use
- * @param count the count of column names to generate
- * @returns an array of column names
- */
-function generateHeader(columnPrefix, count = 0) {
-    const headers = [];
-    for (let i = 0; i < count; i++) {
-        headers.push(`${columnPrefix}${i + 1}`);
-    }
-    return headers;
-}
-function deduceSchema(row, headerRow) {
-    const schema = headerRow ? {} : [];
-    for (let i = 0; i < row.length; i++) {
-        const columnName = (headerRow && headerRow[i]) || i;
-        const value = row[i];
-        switch (typeof value) {
-            case 'number':
-            case 'boolean':
-                // TODO - booleans could be handled differently...
-                schema[columnName] = { name: String(columnName), index: i, type: Float32Array };
-                break;
-            case 'string':
-            default:
-                schema[columnName] = { name: String(columnName), index: i, type: Array };
-            // We currently only handle numeric rows
-            // TODO we could offer a function to map strings to numbers?
-        }
-    }
-    return schema;
-}
-exports._typecheckCSVLoader = exports.CSVLoader;

package/dist/csv-writer.js

@@ -1,6 +0,0 @@
-"use strict";
-/* @typedef {import('@loaders.gl/loader-utils').Writer} Writer */
-/*
- * CSV exporter
- * type {Writer}
- */

package/dist/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CSVLoader = void 0;
-var csv_loader_1 = require("./csv-loader");
-Object.defineProperty(exports, "CSVLoader", { enumerable: true, get: function () { return csv_loader_1.CSVLoader; } });

package/dist/papaparse/async-iterator-streamer.js

@@ -1,63 +0,0 @@
-"use strict";
-// @ts-nocheck
-// A custom papaparse `Streamer` for async iterators
-// Ideally this can be contributed back to papaparse
-// Or papaparse can expose Streamer API so we can extend without forking.
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-invalid-this */
-// Note: papaparse is not an ES6 module
-const papaparse_1 = __importDefault(require("./papaparse"));
-const { ChunkStreamer } = papaparse_1.default;
-function AsyncIteratorStreamer(config) {
-    config = config || {};
-    ChunkStreamer.call(this, config);
-    this.textDecoder = new TextDecoder(this._config.encoding);
-    // Implement ChunkStreamer base class methods
-    // this.pause = function() {
-    //   ChunkStreamer.prototype.pause.apply(this, arguments);
-    // };
-    // this.resume = function() {
-    //   ChunkStreamer.prototype.resume.apply(this, arguments);
-    //   this._input.resume();
-    // };
-    this.stream = async function (asyncIterator) {
-        this._input = asyncIterator;
-        try {
-            // ES2018 version
-            // TODO - check for pause and abort flags?
-            for await (const chunk of asyncIterator) {
-                this.parseChunk(this.getStringChunk(chunk));
-            }
-            // ES5 VERSION
-            // while (true) {
-            //   asyncIterator.next().then(function(value) {
-            //     if (value.done) {
-            //       // finalize iterator?
-            //     }
-            //   }
-            //   const  = await ;
-            //   if (done) return total;
-            //   total += value.length;
-            // }
-            this._finished = true;
-            this.parseChunk('');
-        }
-        catch (error) {
-            // Inform ChunkStreamer base class of error
-            this._sendError(error);
-        }
-    };
-    this._nextChunk = function nextChunk() {
-        // Left empty, as async iterator automatically pulls next chunk
-    };
-    // HELPER METHODS
-    this.getStringChunk = function (chunk) {
-        return typeof chunk === 'string' ? chunk : this.textDecoder.decode(chunk, { stream: true });
-    };
-}
-exports.default = AsyncIteratorStreamer;
-AsyncIteratorStreamer.prototype = Object.create(ChunkStreamer.prototype);
-AsyncIteratorStreamer.prototype.constructor = AsyncIteratorStreamer;

package/dist/papaparse/papaparse.js

@@ -1,935 +0,0 @@
-"use strict";
-// @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
-Object.defineProperty(exports, "__esModule", { value: true });
-/* 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,
-    // Configurable chunk sizes for local and remote files, respectively
-    LocalChunkSize: 1024 * 1024 * 10,
-    RemoteChunkSize: 1024 * 1024 * 5,
-    DefaultDelimiter: ',',
-    // Exposed for testing and development only
-    Parser: Parser,
-    ParserHandle: ParserHandle,
-    // BEGIN FORK
-    ChunkStreamer: ChunkStreamer,
-    StringStreamer: StringStreamer
-};
-exports.default = Papa;
-/*
-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
-) {
-    _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;
-    }
-    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 ((globalThis.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);
-    }
-    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);
-    }
-    // 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;
-        }
-        if (typeof _config.quotes === 'boolean' || Array.isArray(_config.quotes))
-            _quotes = _config.quotes;
-        if (typeof _config.skipEmptyLines === 'boolean' || typeof _config.skipEmptyLines === 'string')
-            _skipEmptyLines = _config.skipEmptyLines;
-        if (typeof _config.newline === 'string')
-            _newline = _config.newline;
-        if (typeof _config.quoteChar === 'string')
-            _quoteChar = _config.quoteChar;
-        if (typeof _config.header === 'boolean')
-            _writeHeader = _config.header;
-        if (Array.isArray(_config.columns)) {
-            if (_config.columns.length === 0)
-                throw new Error('Option columns is empty');
-            _columns = _config.columns;
-        }
-        if (_config.escapeChar !== undefined) {
-            _escapedQuote = _config.escapeChar + _quoteChar;
-        }
-    }
-    /** 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;
-            }
-            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;
-    }
-    /** 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;
-    }
-    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;
-    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
-    }
-}
-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);
-    };
-}
-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 _results = {
-        // The last results returned from the parser
-        data: [],
-        errors: [],
-        meta: {}
-    };
-    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);
-            }
-        };
-    }
-    /**
-     * 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.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;
-        }
-        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();
-    }
-    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);
-        }
-        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);
-    }
-    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;
-        }
-        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;
-        }
-        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;
-                }
-                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
-        });
-    }
-}
-/** https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions */
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
-}
-/** 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;
-    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;
-    }
-    // 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 (;;) {
-            // 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,
-                                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,
-                        index: cursor
-                    });
-                    quoteSearch++;
-                    continue;
-                }
-                if (stepIsFunction) {
-                    doStep();
-                    if (aborted)
-                        return returnable();
-                }
-                if (preview && data.length >= preview)
-                    return returnable(true);
-                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();
-                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;
-                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;
-            }
-            break;
-        }
-        return finish();
-        function pushRow(row) {
-            data.push(row);
-            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
-            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);
-            row = [];
-            nextNewline = input.indexOf(newline, 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.');
-}
-/** 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';
-}