made with requirebin
Created
October 4, 2016 15:55
-
-
Save Hypercubed/a9bc24482b343f8b13d1687c87a6f839 to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /* Given a list of positions: | |
| ('long', 50, 09-01-2015, 09-30-2015) | |
| ('short', 100, 09-15-2015, 10-15-2015) | |
| ('long', 50, 11-01-2015, 11-15,2015) | |
| A stock like AAPL. | |
| 09-01 09-15 50 | |
| 09-15 09-30 -50 | |
| 09-30 10-15 -100 */ | |
| const Papa = require('papaparse'); | |
| const csv = 'type,shares,start,stop\nlong,50,09-01-2015,09-30-2015\nshort,50,09-01-2015,09-30-2015\nlong,50,9-15-2015,9-30-2015'; | |
| let data = Papa.parse(csv, {delimiter:',', header: true}).data; | |
| let p = []; | |
| for (let i = 0; i < data.length; i++) { | |
| const d = data[i]; | |
| p.push({ | |
| type: d.type, | |
| date: +(new Date(d.start)), | |
| shares: +d.shares, | |
| }); | |
| p.push({ | |
| type: d.type, | |
| date: +(new Date(d.stop)), | |
| shares: -d.shares, | |
| }); | |
| } | |
| p = p.sort((a, b) => a.date - b.date); | |
| let sum = 0; | |
| let dt = 0; | |
| let max = -Infinity; | |
| for (let i = 0; i < p.length - 1; i++) { | |
| sum += p[i].type === 'long' ? +p[i].shares : -p[i].shares; | |
| dt = (sum === 0) ? 0 : (dt + p[i+1].date - p[i].date); | |
| max = Math.max(sum, max, dt); | |
| } | |
| console.log('max', max / 1000 / 60 / 60, 'hrs'); |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| setTimeout(function(){ | |
| ;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"papaparse":[function(require,module,exports){ | |
| /*! | |
| Papa Parse | |
| v4.1.2 | |
| https://github.com/mholt/PapaParse | |
| */ | |
| (function(global) | |
| { | |
| "use strict"; | |
| var IS_WORKER = !global.document && !!global.postMessage, | |
| IS_PAPA_WORKER = IS_WORKER && /(\?|&)papaworker(=|&|$)/.test(global.location.search), | |
| LOADED_SYNC = false, AUTO_SCRIPT_PATH; | |
| var workers = {}, workerIdCounter = 0; | |
| var Papa = {}; | |
| Papa.parse = CsvToJson; | |
| Papa.unparse = JsonToCsv; | |
| Papa.RECORD_SEP = String.fromCharCode(30); | |
| Papa.UNIT_SEP = String.fromCharCode(31); | |
| Papa.BYTE_ORDER_MARK = "\ufeff"; | |
| Papa.BAD_DELIMITERS = ["\r", "\n", "\"", Papa.BYTE_ORDER_MARK]; | |
| Papa.WORKERS_SUPPORTED = !IS_WORKER && !!global.Worker; | |
| Papa.SCRIPT_PATH = null; // Must be set by your code if you use workers and this lib is loaded asynchronously | |
| // Configurable chunk sizes for local and remote files, respectively | |
| Papa.LocalChunkSize = 1024 * 1024 * 10; // 10 MB | |
| Papa.RemoteChunkSize = 1024 * 1024 * 5; // 5 MB | |
| Papa.DefaultDelimiter = ","; // Used if not specified and detection fails | |
| // Exposed for testing and development only | |
| Papa.Parser = Parser; | |
| Papa.ParserHandle = ParserHandle; | |
| Papa.NetworkStreamer = NetworkStreamer; | |
| Papa.FileStreamer = FileStreamer; | |
| Papa.StringStreamer = StringStreamer; | |
| if (typeof module !== 'undefined' && module.exports) | |
| { | |
| // Export to Node... | |
| module.exports = Papa; | |
| } | |
| else if (isFunction(global.define) && global.define.amd) | |
| { | |
| // Wireup with RequireJS | |
| define(function() { return Papa; }); | |
| } | |
| else | |
| { | |
| // ...or as browser global | |
| global.Papa = Papa; | |
| } | |
| if (global.jQuery) | |
| { | |
| var $ = global.jQuery; | |
| $.fn.parse = function(options) | |
| { | |
| var config = options.config || {}; | |
| var queue = []; | |
| this.each(function(idx) | |
| { | |
| var supported = $(this).prop('tagName').toUpperCase() == "INPUT" | |
| && $(this).attr('type').toLowerCase() == "file" | |
| && global.FileReader; | |
| if (!supported || !this.files || this.files.length == 0) | |
| return true; // continue to next input element | |
| for (var i = 0; i < this.files.length; i++) | |
| { | |
| queue.push({ | |
| file: this.files[i], | |
| inputElem: this, | |
| instanceConfig: $.extend({}, config) | |
| }); | |
| } | |
| }); | |
| parseNextFile(); // begin parsing | |
| return this; // maintains chainability | |
| function parseNextFile() | |
| { | |
| if (queue.length == 0) | |
| { | |
| if (isFunction(options.complete)) | |
| options.complete(); | |
| return; | |
| } | |
| var f = queue[0]; | |
| if (isFunction(options.before)) | |
| { | |
| var returned = options.before(f.file, f.inputElem); | |
| if (typeof returned === 'object') | |
| { | |
| if (returned.action == "abort") | |
| { | |
| error("AbortError", f.file, f.inputElem, returned.reason); | |
| return; // Aborts all queued files immediately | |
| } | |
| else if (returned.action == "skip") | |
| { | |
| fileComplete(); // parse the next file in the queue, if any | |
| return; | |
| } | |
| else if (typeof returned.config === 'object') | |
| f.instanceConfig = $.extend(f.instanceConfig, returned.config); | |
| } | |
| else if (returned == "skip") | |
| { | |
| fileComplete(); // parse the next file in the queue, if any | |
| return; | |
| } | |
| } | |
| // Wrap up the user's complete callback, if any, so that ours also gets executed | |
| var userCompleteFunc = f.instanceConfig.complete; | |
| f.instanceConfig.complete = function(results) | |
| { | |
| if (isFunction(userCompleteFunc)) | |
| userCompleteFunc(results, f.file, f.inputElem); | |
| fileComplete(); | |
| }; | |
| Papa.parse(f.file, f.instanceConfig); | |
| } | |
| function error(name, file, elem, reason) | |
| { | |
| if (isFunction(options.error)) | |
| options.error({name: name}, file, elem, reason); | |
| } | |
| function fileComplete() | |
| { | |
| queue.splice(0, 1); | |
| parseNextFile(); | |
| } | |
| } | |
| } | |
| if (IS_PAPA_WORKER) | |
| { | |
| global.onmessage = workerThreadReceivedMessage; | |
| } | |
| else if (Papa.WORKERS_SUPPORTED) | |
| { | |
| AUTO_SCRIPT_PATH = getScriptPath(); | |
| // Check if the script was loaded synchronously | |
| if (!document.body) | |
| { | |
| // Body doesn't exist yet, must be synchronous | |
| LOADED_SYNC = true; | |
| } | |
| else | |
| { | |
| document.addEventListener('DOMContentLoaded', function () { | |
| LOADED_SYNC = true; | |
| }, true); | |
| } | |
| } | |
| function CsvToJson(_input, _config) | |
| { | |
| _config = _config || {}; | |
| 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 (typeof _input === 'string') | |
| { | |
| if (_config.download) | |
| streamer = new NetworkStreamer(_config); | |
| else | |
| streamer = new StringStreamer(_config); | |
| } | |
| else if ((global.File && _input instanceof File) || _input instanceof Object) // ...Safari. (see issue #106) | |
| streamer = new FileStreamer(_config); | |
| return streamer.stream(_input); | |
| } | |
| function JsonToCsv(_input, _config) | |
| { | |
| var _output = ""; | |
| var _fields = []; | |
| // Default configuration | |
| /** whether to surround every datum with quotes */ | |
| var _quotes = false; | |
| /** delimiting character */ | |
| var _delimiter = ","; | |
| /** newline character(s) */ | |
| var _newline = "\r\n"; | |
| unpackConfig(); | |
| if (typeof _input === 'string') | |
| _input = JSON.parse(_input); | |
| if (_input instanceof Array) | |
| { | |
| if (!_input.length || _input[0] instanceof Array) | |
| return serialize(null, _input); | |
| else if (typeof _input[0] === 'object') | |
| return serialize(objectKeys(_input[0]), _input); | |
| } | |
| else if (typeof _input === 'object') | |
| { | |
| if (typeof _input.data === 'string') | |
| _input.data = JSON.parse(_input.data); | |
| if (_input.data instanceof Array) | |
| { | |
| if (!_input.fields) | |
| _input.fields = _input.data[0] instanceof Array | |
| ? _input.fields | |
| : objectKeys(_input.data[0]); | |
| if (!(_input.data[0] instanceof Array) && typeof _input.data[0] !== 'object') | |
| _input.data = [_input.data]; // handles input like [1,2,3] or ["asdf"] | |
| } | |
| return serialize(_input.fields || [], _input.data || []); | |
| } | |
| // Default (any valid paths should return before this) | |
| throw "exception: Unable to serialize unrecognized input"; | |
| function unpackConfig() | |
| { | |
| if (typeof _config !== 'object') | |
| return; | |
| if (typeof _config.delimiter === 'string' | |
| && _config.delimiter.length == 1 | |
| && Papa.BAD_DELIMITERS.indexOf(_config.delimiter) == -1) | |
| { | |
| _delimiter = _config.delimiter; | |
| } | |
| if (typeof _config.quotes === 'boolean' | |
| || _config.quotes instanceof Array) | |
| _quotes = _config.quotes; | |
| if (typeof _config.newline === 'string') | |
| _newline = _config.newline; | |
| } | |
| /** 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) | |
| { | |
| var csv = ""; | |
| if (typeof fields === 'string') | |
| fields = JSON.parse(fields); | |
| if (typeof data === 'string') | |
| data = JSON.parse(data); | |
| var hasHeader = fields instanceof Array && fields.length > 0; | |
| var dataKeyedByField = !(data[0] instanceof Array); | |
| // If there a header row, write it first | |
| if (hasHeader) | |
| { | |
| 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; | |
| for (var col = 0; col < maxCol; col++) | |
| { | |
| if (col > 0) | |
| csv += _delimiter; | |
| var colIdx = hasHeader && dataKeyedByField ? fields[col] : col; | |
| csv += safe(data[row][colIdx], col); | |
| } | |
| if (row < data.length - 1) | |
| 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 ""; | |
| str = str.toString().replace(/"/g, '""'); | |
| var needsQuotes = (typeof _quotes === 'boolean' && _quotes) | |
| || (_quotes instanceof Array && _quotes[col]) | |
| || hasAny(str, Papa.BAD_DELIMITERS) | |
| || str.indexOf(_delimiter) > -1 | |
| || str.charAt(0) == ' ' | |
| || str.charAt(str.length - 1) == ' '; | |
| return needsQuotes ? '"' + str + '"' : 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._paused = false; | |
| this._finished = 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) | |
| { | |
| // 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 (IS_PAPA_WORKER) | |
| { | |
| global.postMessage({ | |
| results: results, | |
| workerId: Papa.WORKER_ID, | |
| finished: finishedIncludingPreview | |
| }); | |
| } | |
| else if (isFunction(this._config.chunk)) | |
| { | |
| this._config.chunk(results, this._handle); | |
| if (this._paused) | |
| 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 (finishedIncludingPreview && isFunction(this._config.complete) && (!results || !results.meta.aborted)) | |
| this._config.complete(this._completeResults); | |
| if (!finishedIncludingPreview && (!results || !results.meta.paused)) | |
| this._nextChunk(); | |
| return results; | |
| }; | |
| this._sendError = function(error) | |
| { | |
| if (isFunction(this._config.error)) | |
| this._config.error(error); | |
| else if (IS_PAPA_WORKER && this._config.error) | |
| { | |
| global.postMessage({ | |
| workerId: Papa.WORKER_ID, | |
| error: error, | |
| finished: false | |
| }); | |
| } | |
| }; | |
| function replaceConfig(config) | |
| { | |
| // Deep-copy the config so we can edit it | |
| var configCopy = copy(config); | |
| configCopy.chunkSize = parseInt(configCopy.chunkSize); // parseInt VERY important so we don't concatenate strings! | |
| if (!config.step && !config.chunk) | |
| configCopy.chunkSize = null; // disable Range header if not streaming; bad values break IIS - see issue #196 | |
| this._handle = new ParserHandle(configCopy); | |
| this._handle.streamer = this; | |
| this._config = configCopy; // persist the copy to the caller | |
| } | |
| } | |
| function NetworkStreamer(config) | |
| { | |
| config = config || {}; | |
| if (!config.chunkSize) | |
| config.chunkSize = Papa.RemoteChunkSize; | |
| ChunkStreamer.call(this, config); | |
| var xhr; | |
| if (IS_WORKER) | |
| { | |
| this._nextChunk = function() | |
| { | |
| this._readChunk(); | |
| this._chunkLoaded(); | |
| }; | |
| } | |
| else | |
| { | |
| this._nextChunk = function() | |
| { | |
| this._readChunk(); | |
| }; | |
| } | |
| this.stream = function(url) | |
| { | |
| this._input = url; | |
| this._nextChunk(); // Starts streaming | |
| }; | |
| this._readChunk = function() | |
| { | |
| if (this._finished) | |
| { | |
| this._chunkLoaded(); | |
| return; | |
| } | |
| xhr = new XMLHttpRequest(); | |
| if (!IS_WORKER) | |
| { | |
| xhr.onload = bindFunction(this._chunkLoaded, this); | |
| xhr.onerror = bindFunction(this._chunkError, this); | |
| } | |
| xhr.open("GET", this._input, !IS_WORKER); | |
| if (this._config.chunkSize) | |
| { | |
| var end = this._start + this._config.chunkSize - 1; // minus one because byte range is inclusive | |
| xhr.setRequestHeader("Range", "bytes="+this._start+"-"+end); | |
| xhr.setRequestHeader("If-None-Match", "webkit-no-cache"); // https://bugs.webkit.org/show_bug.cgi?id=82672 | |
| } | |
| try { | |
| xhr.send(); | |
| } | |
| catch (err) { | |
| this._chunkError(err.message); | |
| } | |
| if (IS_WORKER && xhr.status == 0) | |
| this._chunkError(); | |
| else | |
| this._start += this._config.chunkSize; | |
| } | |
| this._chunkLoaded = function() | |
| { | |
| if (xhr.readyState != 4) | |
| return; | |
| if (xhr.status < 200 || xhr.status >= 400) | |
| { | |
| this._chunkError(); | |
| return; | |
| } | |
| this._finished = !this._config.chunkSize || this._start > getFileSize(xhr); | |
| this.parseChunk(xhr.responseText); | |
| } | |
| this._chunkError = function(errorMessage) | |
| { | |
| var errorText = xhr.statusText || errorMessage; | |
| this._sendError(errorText); | |
| } | |
| function getFileSize(xhr) | |
| { | |
| var contentRange = xhr.getResponseHeader("Content-Range"); | |
| return parseInt(contentRange.substr(contentRange.lastIndexOf("/") + 1)); | |
| } | |
| } | |
| NetworkStreamer.prototype = Object.create(ChunkStreamer.prototype); | |
| NetworkStreamer.prototype.constructor = NetworkStreamer; | |
| function FileStreamer(config) | |
| { | |
| config = config || {}; | |
| if (!config.chunkSize) | |
| config.chunkSize = Papa.LocalChunkSize; | |
| ChunkStreamer.call(this, config); | |
| var reader, slice; | |
| // FileReader is better than FileReaderSync (even in worker) - see http://stackoverflow.com/q/24708649/1048862 | |
| // But Firefox is a pill, too - see issue #76: https://github.com/mholt/PapaParse/issues/76 | |
| var usingAsyncReader = typeof FileReader !== 'undefined'; // Safari doesn't consider it a function - see issue #105 | |
| this.stream = function(file) | |
| { | |
| this._input = file; | |
| slice = file.slice || file.webkitSlice || file.mozSlice; | |
| if (usingAsyncReader) | |
| { | |
| reader = new FileReader(); // Preferred method of reading files, even in workers | |
| reader.onload = bindFunction(this._chunkLoaded, this); | |
| reader.onerror = bindFunction(this._chunkError, this); | |
| } | |
| else | |
| reader = new FileReaderSync(); // Hack for running in a web worker in Firefox | |
| this._nextChunk(); // Starts streaming | |
| }; | |
| this._nextChunk = function() | |
| { | |
| if (!this._finished && (!this._config.preview || this._rowCount < this._config.preview)) | |
| this._readChunk(); | |
| } | |
| this._readChunk = function() | |
| { | |
| var input = this._input; | |
| if (this._config.chunkSize) | |
| { | |
| var end = Math.min(this._start + this._config.chunkSize, this._input.size); | |
| input = slice.call(input, this._start, end); | |
| } | |
| var txt = reader.readAsText(input, this._config.encoding); | |
| if (!usingAsyncReader) | |
| this._chunkLoaded({ target: { result: txt } }); // mimic the async signature | |
| } | |
| this._chunkLoaded = function(event) | |
| { | |
| // Very important to increment start each time before handling results | |
| this._start += this._config.chunkSize; | |
| this._finished = !this._config.chunkSize || this._start >= this._input.size; | |
| this.parseChunk(event.target.result); | |
| } | |
| this._chunkError = function() | |
| { | |
| this._sendError(reader.error); | |
| } | |
| } | |
| FileStreamer.prototype = Object.create(ChunkStreamer.prototype); | |
| FileStreamer.prototype.constructor = FileStreamer; | |
| function StringStreamer(config) | |
| { | |
| config = config || {}; | |
| ChunkStreamer.call(this, config); | |
| var string; | |
| var remaining; | |
| this.stream = function(s) | |
| { | |
| string = 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 self = this; | |
| var _stepCounter = 0; // Number of times step was called (number of rows parsed) | |
| 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(); | |
| else // only call user's step function after header row | |
| { | |
| processResults(); | |
| // It's possbile that this line was empty and there's no row here after all | |
| if (_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) | |
| { | |
| if (!_config.newline) | |
| _config.newline = guessLineEndings(input); | |
| _delimiterError = false; | |
| if (!_config.delimiter) | |
| { | |
| var delimGuess = guessDelimiter(input); | |
| 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; | |
| } | |
| 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); | |
| }; | |
| 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 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 (_results.data[i].length == 1 && _results.data[i][0] == "") | |
| _results.data.splice(i--, 1); | |
| } | |
| if (needsHeaderRow()) | |
| fillHeaderFields(); | |
| return applyHeaderAndDynamicTyping(); | |
| } | |
| function needsHeaderRow() | |
| { | |
| return _config.header && _fields.length == 0; | |
| } | |
| function fillHeaderFields() | |
| { | |
| if (!_results) | |
| return; | |
| for (var i = 0; needsHeaderRow() && i < _results.data.length; i++) | |
| for (var j = 0; j < _results.data[i].length; j++) | |
| _fields.push(_results.data[i][j]); | |
| _results.data.splice(0, 1); | |
| } | |
| function applyHeaderAndDynamicTyping() | |
| { | |
| if (!_results || (!_config.header && !_config.dynamicTyping)) | |
| return _results; | |
| for (var i = 0; i < _results.data.length; i++) | |
| { | |
| var row = {}; | |
| for (var j = 0; j < _results.data[i].length; j++) | |
| { | |
| if (_config.dynamicTyping) | |
| { | |
| var value = _results.data[i][j]; | |
| if (value == "true" || value == "TRUE") | |
| _results.data[i][j] = true; | |
| else if (value == "false" || value == "FALSE") | |
| _results.data[i][j] = false; | |
| else | |
| _results.data[i][j] = tryParseFloat(value); | |
| } | |
| if (_config.header) | |
| { | |
| if (j >= _fields.length) | |
| { | |
| if (!row["__parsed_extra"]) | |
| row["__parsed_extra"] = []; | |
| row["__parsed_extra"].push(_results.data[i][j]); | |
| } | |
| else | |
| row[_fields[j]] = _results.data[i][j]; | |
| } | |
| } | |
| if (_config.header) | |
| { | |
| _results.data[i] = row; | |
| if (j > _fields.length) | |
| addError("FieldMismatch", "TooManyFields", "Too many fields: expected " + _fields.length + " fields but parsed " + j, i); | |
| else if (j < _fields.length) | |
| addError("FieldMismatch", "TooFewFields", "Too few fields: expected " + _fields.length + " fields but parsed " + j, i); | |
| } | |
| } | |
| if (_config.header && _results.meta) | |
| _results.meta.fields = _fields; | |
| return _results; | |
| } | |
| function guessDelimiter(input) | |
| { | |
| var delimChoices = [",", "\t", "|", ";", Papa.RECORD_SEP, Papa.UNIT_SEP]; | |
| var bestDelim, bestDelta, fieldCountPrevRow; | |
| for (var i = 0; i < delimChoices.length; i++) | |
| { | |
| var delim = delimChoices[i]; | |
| var delta = 0, avgFieldCount = 0; | |
| fieldCountPrevRow = undefined; | |
| var preview = new Parser({ | |
| delimiter: delim, | |
| preview: 10 | |
| }).parse(input); | |
| for (var j = 0; j < preview.data.length; j++) | |
| { | |
| var fieldCount = preview.data[j].length; | |
| avgFieldCount += fieldCount; | |
| if (typeof fieldCountPrevRow === 'undefined') | |
| { | |
| fieldCountPrevRow = fieldCount; | |
| continue; | |
| } | |
| else if (fieldCount > 1) | |
| { | |
| delta += Math.abs(fieldCount - fieldCountPrevRow); | |
| fieldCountPrevRow = fieldCount; | |
| } | |
| } | |
| if (preview.data.length > 0) | |
| avgFieldCount /= preview.data.length; | |
| if ((typeof bestDelta === 'undefined' || delta < bestDelta) | |
| && avgFieldCount > 1.99) | |
| { | |
| bestDelta = delta; | |
| bestDelim = delim; | |
| } | |
| } | |
| _config.delimiter = bestDelim; | |
| return { | |
| successful: !!bestDelim, | |
| bestDelimiter: bestDelim | |
| } | |
| } | |
| function guessLineEndings(input) | |
| { | |
| input = input.substr(0, 1024*1024); // max length 1 MB | |
| var r = input.split('\r'); | |
| if (r.length == 1) | |
| 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 tryParseFloat(val) | |
| { | |
| var isNumber = FLOAT.test(val); | |
| return isNumber ? parseFloat(val) : val; | |
| } | |
| function addError(type, code, msg, row) | |
| { | |
| _results.errors.push({ | |
| type: type, | |
| code: code, | |
| message: msg, | |
| row: row | |
| }); | |
| } | |
| } | |
| /** 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; | |
| // Delimiter must be valid | |
| if (typeof delim !== 'string' | |
| || Papa.BAD_DELIMITERS.indexOf(delim) > -1) | |
| delim = ","; | |
| // Comment character must be valid | |
| if (comments === delim) | |
| throw "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 "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 = typeof step === 'function'; | |
| // Establish starting state | |
| cursor = 0; | |
| var data = [], errors = [], row = [], lastCursor = 0; | |
| if (!input) | |
| return returnable(); | |
| if (fastMode || (fastMode !== false && input.indexOf('"') === -1)) | |
| { | |
| var rows = input.split(newline); | |
| for (var i = 0; i < rows.length; i++) | |
| { | |
| var 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); | |
| // Parser loop | |
| for (;;) | |
| { | |
| // Field has opening quote | |
| if (input[cursor] == '"') | |
| { | |
| // Start our search for the closing quote where the cursor is | |
| var quoteSearch = cursor; | |
| // Skip the opening quote | |
| cursor++; | |
| for (;;) | |
| { | |
| // Find closing quote | |
| var quoteSearch = input.indexOf('"', quoteSearch+1); | |
| 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(); | |
| } | |
| if (quoteSearch === inputLen-1) | |
| { | |
| // Closing quote at EOF | |
| var value = input.substring(cursor, quoteSearch).replace(/""/g, '"'); | |
| return finish(value); | |
| } | |
| // If this quote is escaped, it's part of the data; skip it | |
| if (input[quoteSearch+1] == '"') | |
| { | |
| quoteSearch++; | |
| continue; | |
| } | |
| if (input[quoteSearch+1] == delim) | |
| { | |
| // Closing quote followed by delimiter | |
| row.push(input.substring(cursor, quoteSearch).replace(/""/g, '"')); | |
| cursor = quoteSearch + 1 + delimLen; | |
| nextDelim = input.indexOf(delim, cursor); | |
| nextNewline = input.indexOf(newline, cursor); | |
| break; | |
| } | |
| if (input.substr(quoteSearch+1, newlineLen) === newline) | |
| { | |
| // Closing quote followed by newline | |
| row.push(input.substring(cursor, quoteSearch).replace(/""/g, '"')); | |
| saveRow(quoteSearch + 1 + 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; | |
| } | |
| } | |
| 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; | |
| } | |
| /** | |
| * 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) | |
| { | |
| return { | |
| data: 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()); | |
| data = [], errors = []; | |
| } | |
| }; | |
| /** Sets the abort flag */ | |
| this.abort = function() | |
| { | |
| aborted = true; | |
| }; | |
| /** Gets the cursor position */ | |
| this.getCharIndex = function() | |
| { | |
| return cursor; | |
| }; | |
| } | |
| // If you need to load Papa Parse asynchronously and you also need worker threads, hard-code | |
| // the script path here. See: https://github.com/mholt/PapaParse/issues/87#issuecomment-57885358 | |
| function getScriptPath() | |
| { | |
| var scripts = document.getElementsByTagName('script'); | |
| return scripts.length ? scripts[scripts.length - 1].src : ''; | |
| } | |
| function newWorker() | |
| { | |
| if (!Papa.WORKERS_SUPPORTED) | |
| return false; | |
| if (!LOADED_SYNC && Papa.SCRIPT_PATH === null) | |
| throw new Error( | |
| 'Script path cannot be determined automatically when Papa Parse is loaded asynchronously. ' + | |
| 'You need to set Papa.SCRIPT_PATH manually.' | |
| ); | |
| var workerUrl = Papa.SCRIPT_PATH || AUTO_SCRIPT_PATH; | |
| // Append "papaworker" to the search string to tell papaparse that this is our worker. | |
| workerUrl += (workerUrl.indexOf('?') !== -1 ? '&' : '?') + 'papaworker'; | |
| var w = new global.Worker(workerUrl); | |
| w.onmessage = mainThreadReceivedMessage; | |
| w.id = workerIdCounter++; | |
| workers[w.id] = w; | |
| return w; | |
| } | |
| /** Callback when main thread receives a message */ | |
| function mainThreadReceivedMessage(e) | |
| { | |
| var msg = e.data; | |
| var worker = workers[msg.workerId]; | |
| var aborted = false; | |
| if (msg.error) | |
| worker.userError(msg.error, msg.file); | |
| else if (msg.results && msg.results.data) | |
| { | |
| var abort = function() { | |
| aborted = true; | |
| completeWorker(msg.workerId, { data: [], errors: [], meta: { aborted: true } }); | |
| }; | |
| var handle = { | |
| abort: abort, | |
| pause: notImplemented, | |
| resume: notImplemented | |
| }; | |
| if (isFunction(worker.userStep)) | |
| { | |
| for (var i = 0; i < msg.results.data.length; i++) | |
| { | |
| worker.userStep({ | |
| data: [msg.results.data[i]], | |
| errors: msg.results.errors, | |
| meta: msg.results.meta | |
| }, handle); | |
| if (aborted) | |
| break; | |
| } | |
| delete msg.results; // free memory ASAP | |
| } | |
| else if (isFunction(worker.userChunk)) | |
| { | |
| worker.userChunk(msg.results, handle, msg.file); | |
| delete msg.results; | |
| } | |
| } | |
| if (msg.finished && !aborted) | |
| completeWorker(msg.workerId, msg.results); | |
| } | |
| function completeWorker(workerId, results) { | |
| var worker = workers[workerId]; | |
| if (isFunction(worker.userComplete)) | |
| worker.userComplete(results); | |
| worker.terminate(); | |
| delete workers[workerId]; | |
| } | |
| function notImplemented() { | |
| throw "Not implemented."; | |
| } | |
| /** Callback when worker thread receives a message */ | |
| function workerThreadReceivedMessage(e) | |
| { | |
| var msg = e.data; | |
| if (typeof Papa.WORKER_ID === 'undefined' && msg) | |
| Papa.WORKER_ID = msg.workerId; | |
| if (typeof msg.input === 'string') | |
| { | |
| global.postMessage({ | |
| workerId: Papa.WORKER_ID, | |
| results: Papa.parse(msg.input, msg.config), | |
| finished: true | |
| }); | |
| } | |
| else if ((global.File && msg.input instanceof File) || msg.input instanceof Object) // thank you, Safari (see issue #106) | |
| { | |
| var results = Papa.parse(msg.input, msg.config); | |
| if (results) | |
| global.postMessage({ | |
| workerId: Papa.WORKER_ID, | |
| results: results, | |
| finished: true | |
| }); | |
| } | |
| } | |
| /** Makes a deep copy of an array or object (mostly) */ | |
| function copy(obj) | |
| { | |
| if (typeof obj !== 'object') | |
| return obj; | |
| var cpy = obj instanceof Array ? [] : {}; | |
| for (var key in obj) | |
| cpy[key] = copy(obj[key]); | |
| return cpy; | |
| } | |
| function bindFunction(f, self) | |
| { | |
| return function() { f.apply(self, arguments); }; | |
| } | |
| function isFunction(func) | |
| { | |
| return typeof func === 'function'; | |
| } | |
| })(typeof window !== 'undefined' ? window : this); | |
| },{}]},{},[]) | |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","papaparse.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/*!\n\tPapa Parse\n\tv4.1.2\n\thttps://github.com/mholt/PapaParse\n*/\n(function(global)\n{\n\t\"use strict\";\n\n\tvar IS_WORKER = !global.document && !!global.postMessage,\n\t\tIS_PAPA_WORKER = IS_WORKER && /(\\?|&)papaworker(=|&|$)/.test(global.location.search),\n\t\tLOADED_SYNC = false, AUTO_SCRIPT_PATH;\n\tvar workers = {}, workerIdCounter = 0;\n\n\tvar Papa = {};\n\n\tPapa.parse = CsvToJson;\n\tPapa.unparse = JsonToCsv;\n\n\tPapa.RECORD_SEP = String.fromCharCode(30);\n\tPapa.UNIT_SEP = String.fromCharCode(31);\n\tPapa.BYTE_ORDER_MARK = \"\\ufeff\";\n\tPapa.BAD_DELIMITERS = [\"\\r\", \"\\n\", \"\\\"\", Papa.BYTE_ORDER_MARK];\n\tPapa.WORKERS_SUPPORTED = !IS_WORKER && !!global.Worker;\n\tPapa.SCRIPT_PATH = null;\t// Must be set by your code if you use workers and this lib is loaded asynchronously\n\n\t// Configurable chunk sizes for local and remote files, respectively\n\tPapa.LocalChunkSize = 1024 * 1024 * 10;\t// 10 MB\n\tPapa.RemoteChunkSize = 1024 * 1024 * 5;\t// 5 MB\n\tPapa.DefaultDelimiter = \",\";\t\t\t// Used if not specified and detection fails\n\n\t// Exposed for testing and development only\n\tPapa.Parser = Parser;\n\tPapa.ParserHandle = ParserHandle;\n\tPapa.NetworkStreamer = NetworkStreamer;\n\tPapa.FileStreamer = FileStreamer;\n\tPapa.StringStreamer = StringStreamer;\n\n\tif (typeof module !== 'undefined' && module.exports)\n\t{\n\t\t// Export to Node...\n\t\tmodule.exports = Papa;\n\t}\n\telse if (isFunction(global.define) && global.define.amd)\n\t{\n\t\t// Wireup with RequireJS\n\t\tdefine(function() { return Papa; });\n\t}\n\telse\n\t{\n\t\t// ...or as browser global\n\t\tglobal.Papa = Papa;\n\t}\n\n\tif (global.jQuery)\n\t{\n\t\tvar $ = global.jQuery;\n\t\t$.fn.parse = function(options)\n\t\t{\n\t\t\tvar config = options.config || {};\n\t\t\tvar queue = [];\n\n\t\t\tthis.each(function(idx)\n\t\t\t{\n\t\t\t\tvar supported = $(this).prop('tagName').toUpperCase() == \"INPUT\"\n\t\t\t\t\t\t\t\t&& $(this).attr('type').toLowerCase() == \"file\"\n\t\t\t\t\t\t\t\t&& global.FileReader;\n\n\t\t\t\tif (!supported || !this.files || this.files.length == 0)\n\t\t\t\t\treturn true;\t// continue to next input element\n\n\t\t\t\tfor (var i = 0; i < this.files.length; i++)\n\t\t\t\t{\n\t\t\t\t\tqueue.push({\n\t\t\t\t\t\tfile: this.files[i],\n\t\t\t\t\t\tinputElem: this,\n\t\t\t\t\t\tinstanceConfig: $.extend({}, config)\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tparseNextFile();\t// begin parsing\n\t\t\treturn this;\t\t// maintains chainability\n\n\n\t\t\tfunction parseNextFile()\n\t\t\t{\n\t\t\t\tif (queue.length == 0)\n\t\t\t\t{\n\t\t\t\t\tif (isFunction(options.complete))\n\t\t\t\t\t\toptions.complete();\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar f = queue[0];\n\n\t\t\t\tif (isFunction(options.before))\n\t\t\t\t{\n\t\t\t\t\tvar returned = options.before(f.file, f.inputElem);\n\n\t\t\t\t\tif (typeof returned === 'object')\n\t\t\t\t\t{\n\t\t\t\t\t\tif (returned.action == \"abort\")\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\terror(\"AbortError\", f.file, f.inputElem, returned.reason);\n\t\t\t\t\t\t\treturn;\t// Aborts all queued files immediately\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if (returned.action == \"skip\")\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfileComplete();\t// parse the next file in the queue, if any\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if (typeof returned.config === 'object')\n\t\t\t\t\t\t\tf.instanceConfig = $.extend(f.instanceConfig, returned.config);\n\t\t\t\t\t}\n\t\t\t\t\telse if (returned == \"skip\")\n\t\t\t\t\t{\n\t\t\t\t\t\tfileComplete();\t// parse the next file in the queue, if any\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Wrap up the user's complete callback, if any, so that ours also gets executed\n\t\t\t\tvar userCompleteFunc = f.instanceConfig.complete;\n\t\t\t\tf.instanceConfig.complete = function(results)\n\t\t\t\t{\n\t\t\t\t\tif (isFunction(userCompleteFunc))\n\t\t\t\t\t\tuserCompleteFunc(results, f.file, f.inputElem);\n\t\t\t\t\tfileComplete();\n\t\t\t\t};\n\n\t\t\t\tPapa.parse(f.file, f.instanceConfig);\n\t\t\t}\n\n\t\t\tfunction error(name, file, elem, reason)\n\t\t\t{\n\t\t\t\tif (isFunction(options.error))\n\t\t\t\t\toptions.error({name: name}, file, elem, reason);\n\t\t\t}\n\n\t\t\tfunction fileComplete()\n\t\t\t{\n\t\t\t\tqueue.splice(0, 1);\n\t\t\t\tparseNextFile();\n\t\t\t}\n\t\t}\n\t}\n\n\n\tif (IS_PAPA_WORKER)\n\t{\n\t\tglobal.onmessage = workerThreadReceivedMessage;\n\t}\n\telse if (Papa.WORKERS_SUPPORTED)\n\t{\n\t\tAUTO_SCRIPT_PATH = getScriptPath();\n\n\t\t// Check if the script was loaded synchronously\n\t\tif (!document.body)\n\t\t{\n\t\t\t// Body doesn't exist yet, must be synchronous\n\t\t\tLOADED_SYNC = true;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tdocument.addEventListener('DOMContentLoaded', function () {\n\t\t\t\tLOADED_SYNC = true;\n\t\t\t}, true);\n\t\t}\n\t}\n\n\n\n\n\tfunction CsvToJson(_input, _config)\n\t{\n\t\t_config = _config || {};\n\n\t\tif (_config.worker && Papa.WORKERS_SUPPORTED)\n\t\t{\n\t\t\tvar w = newWorker();\n\n\t\t\tw.userStep = _config.step;\n\t\t\tw.userChunk = _config.chunk;\n\t\t\tw.userComplete = _config.complete;\n\t\t\tw.userError = _config.error;\n\n\t\t\t_config.step = isFunction(_config.step);\n\t\t\t_config.chunk = isFunction(_config.chunk);\n\t\t\t_config.complete = isFunction(_config.complete);\n\t\t\t_config.error = isFunction(_config.error);\n\t\t\tdelete _config.worker;\t// prevent infinite loop\n\n\t\t\tw.postMessage({\n\t\t\t\tinput: _input,\n\t\t\t\tconfig: _config,\n\t\t\t\tworkerId: w.id\n\t\t\t});\n\n\t\t\treturn;\n\t\t}\n\n\t\tvar streamer = null;\n\t\tif (typeof _input === 'string')\n\t\t{\n\t\t\tif (_config.download)\n\t\t\t\tstreamer = new NetworkStreamer(_config);\n\t\t\telse\n\t\t\t\tstreamer = new StringStreamer(_config);\n\t\t}\n\t\telse if ((global.File && _input instanceof File) || _input instanceof Object)\t// ...Safari. (see issue #106)\n\t\t\tstreamer = new FileStreamer(_config);\n\n\t\treturn streamer.stream(_input);\n\t}\n\n\n\n\n\n\n\tfunction JsonToCsv(_input, _config)\n\t{\n\t\tvar _output = \"\";\n\t\tvar _fields = [];\n\n\t\t// Default configuration\n\n\t\t/** whether to surround every datum with quotes */\n\t\tvar _quotes = false;\n\n\t\t/** delimiting character */\n\t\tvar _delimiter = \",\";\n\n\t\t/** newline character(s) */\n\t\tvar _newline = \"\\r\\n\";\n\n\t\tunpackConfig();\n\n\t\tif (typeof _input === 'string')\n\t\t\t_input = JSON.parse(_input);\n\n\t\tif (_input instanceof Array)\n\t\t{\n\t\t\tif (!_input.length || _input[0] instanceof Array)\n\t\t\t\treturn serialize(null, _input);\n\t\t\telse if (typeof _input[0] === 'object')\n\t\t\t\treturn serialize(objectKeys(_input[0]), _input);\n\t\t}\n\t\telse if (typeof _input === 'object')\n\t\t{\n\t\t\tif (typeof _input.data === 'string')\n\t\t\t\t_input.data = JSON.parse(_input.data);\n\n\t\t\tif (_input.data instanceof Array)\n\t\t\t{\n\t\t\t\tif (!_input.fields)\n\t\t\t\t\t_input.fields = _input.data[0] instanceof Array\n\t\t\t\t\t\t\t\t\t? _input.fields\n\t\t\t\t\t\t\t\t\t: objectKeys(_input.data[0]);\n\n\t\t\t\tif (!(_input.data[0] instanceof Array) && typeof _input.data[0] !== 'object')\n\t\t\t\t\t_input.data = [_input.data];\t// handles input like [1,2,3] or [\"asdf\"]\n\t\t\t}\n\n\t\t\treturn serialize(_input.fields || [], _input.data || []);\n\t\t}\n\n\t\t// Default (any valid paths should return before this)\n\t\tthrow \"exception: Unable to serialize unrecognized input\";\n\n\n\t\tfunction unpackConfig()\n\t\t{\n\t\t\tif (typeof _config !== 'object')\n\t\t\t\treturn;\n\n\t\t\tif (typeof _config.delimiter === 'string'\n\t\t\t\t&& _config.delimiter.length == 1\n\t\t\t\t&& Papa.BAD_DELIMITERS.indexOf(_config.delimiter) == -1)\n\t\t\t{\n\t\t\t\t_delimiter = _config.delimiter;\n\t\t\t}\n\n\t\t\tif (typeof _config.quotes === 'boolean'\n\t\t\t\t|| _config.quotes instanceof Array)\n\t\t\t\t_quotes = _config.quotes;\n\n\t\t\tif (typeof _config.newline === 'string')\n\t\t\t\t_newline = _config.newline;\n\t\t}\n\n\n\t\t/** Turns an object's keys into an array */\n\t\tfunction objectKeys(obj)\n\t\t{\n\t\t\tif (typeof obj !== 'object')\n\t\t\t\treturn [];\n\t\t\tvar keys = [];\n\t\t\tfor (var key in obj)\n\t\t\t\tkeys.push(key);\n\t\t\treturn keys;\n\t\t}\n\n\t\t/** The double for loop that iterates the data and writes out a CSV string including header row */\n\t\tfunction serialize(fields, data)\n\t\t{\n\t\t\tvar csv = \"\";\n\n\t\t\tif (typeof fields === 'string')\n\t\t\t\tfields = JSON.parse(fields);\n\t\t\tif (typeof data === 'string')\n\t\t\t\tdata = JSON.parse(data);\n\n\t\t\tvar hasHeader = fields instanceof Array && fields.length > 0;\n\t\t\tvar dataKeyedByField = !(data[0] instanceof Array);\n\n\t\t\t// If there a header row, write it first\n\t\t\tif (hasHeader)\n\t\t\t{\n\t\t\t\tfor (var i = 0; i < fields.length; i++)\n\t\t\t\t{\n\t\t\t\t\tif (i > 0)\n\t\t\t\t\t\tcsv += _delimiter;\n\t\t\t\t\tcsv += safe(fields[i], i);\n\t\t\t\t}\n\t\t\t\tif (data.length > 0)\n\t\t\t\t\tcsv += _newline;\n\t\t\t}\n\n\t\t\t// Then write out the data\n\t\t\tfor (var row = 0; row < data.length; row++)\n\t\t\t{\n\t\t\t\tvar maxCol = hasHeader ? fields.length : data[row].length;\n\n\t\t\t\tfor (var col = 0; col < maxCol; col++)\n\t\t\t\t{\n\t\t\t\t\tif (col > 0)\n\t\t\t\t\t\tcsv += _delimiter;\n\t\t\t\t\tvar colIdx = hasHeader && dataKeyedByField ? fields[col] : col;\n\t\t\t\t\tcsv += safe(data[row][colIdx], col);\n\t\t\t\t}\n\n\t\t\t\tif (row < data.length - 1)\n\t\t\t\t\tcsv += _newline;\n\t\t\t}\n\n\t\t\treturn csv;\n\t\t}\n\n\t\t/** Encloses a value around quotes if needed (makes a value safe for CSV insertion) */\n\t\tfunction safe(str, col)\n\t\t{\n\t\t\tif (typeof str === \"undefined\" || str === null)\n\t\t\t\treturn \"\";\n\n\t\t\tstr = str.toString().replace(/\"/g, '\"\"');\n\n\t\t\tvar needsQuotes = (typeof _quotes === 'boolean' && _quotes)\n\t\t\t\t\t\t\t|| (_quotes instanceof Array && _quotes[col])\n\t\t\t\t\t\t\t|| hasAny(str, Papa.BAD_DELIMITERS)\n\t\t\t\t\t\t\t|| str.indexOf(_delimiter) > -1\n\t\t\t\t\t\t\t|| str.charAt(0) == ' '\n\t\t\t\t\t\t\t|| str.charAt(str.length - 1) == ' ';\n\n\t\t\treturn needsQuotes ? '\"' + str + '\"' : str;\n\t\t}\n\n\t\tfunction hasAny(str, substrings)\n\t\t{\n\t\t\tfor (var i = 0; i < substrings.length; i++)\n\t\t\t\tif (str.indexOf(substrings[i]) > -1)\n\t\t\t\t\treturn true;\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t/** ChunkStreamer is the base prototype for various streamer implementations. */\n\tfunction ChunkStreamer(config)\n\t{\n\t\tthis._handle = null;\n\t\tthis._paused = false;\n\t\tthis._finished = false;\n\t\tthis._input = null;\n\t\tthis._baseIndex = 0;\n\t\tthis._partialLine = \"\";\n\t\tthis._rowCount = 0;\n\t\tthis._start = 0;\n\t\tthis._nextChunk = null;\n\t\tthis.isFirstChunk = true;\n\t\tthis._completeResults = {\n\t\t\tdata: [],\n\t\t\terrors: [],\n\t\t\tmeta: {}\n\t\t};\n\t\treplaceConfig.call(this, config);\n\n\t\tthis.parseChunk = function(chunk)\n\t\t{\n\t\t\t// First chunk pre-processing\n\t\t\tif (this.isFirstChunk && isFunction(this._config.beforeFirstChunk))\n\t\t\t{\n\t\t\t\tvar modifiedChunk = this._config.beforeFirstChunk(chunk);\n\t\t\t\tif (modifiedChunk !== undefined)\n\t\t\t\t\tchunk = modifiedChunk;\n\t\t\t}\n\t\t\tthis.isFirstChunk = false;\n\n\t\t\t// Rejoin the line we likely just split in two by chunking the file\n\t\t\tvar aggregate = this._partialLine + chunk;\n\t\t\tthis._partialLine = \"\";\n\n\t\t\tvar results = this._handle.parse(aggregate, this._baseIndex, !this._finished);\n\t\t\t\n\t\t\tif (this._handle.paused() || this._handle.aborted())\n\t\t\t\treturn;\n\t\t\t\n\t\t\tvar lastIndex = results.meta.cursor;\n\t\t\t\n\t\t\tif (!this._finished)\n\t\t\t{\n\t\t\t\tthis._partialLine = aggregate.substring(lastIndex - this._baseIndex);\n\t\t\t\tthis._baseIndex = lastIndex;\n\t\t\t}\n\n\t\t\tif (results && results.data)\n\t\t\t\tthis._rowCount += results.data.length;\n\n\t\t\tvar finishedIncludingPreview = this._finished || (this._config.preview && this._rowCount >= this._config.preview);\n\n\t\t\tif (IS_PAPA_WORKER)\n\t\t\t{\n\t\t\t\tglobal.postMessage({\n\t\t\t\t\tresults: results,\n\t\t\t\t\tworkerId: Papa.WORKER_ID,\n\t\t\t\t\tfinished: finishedIncludingPreview\n\t\t\t\t});\n\t\t\t}\n\t\t\telse if (isFunction(this._config.chunk))\n\t\t\t{\n\t\t\t\tthis._config.chunk(results, this._handle);\n\t\t\t\tif (this._paused)\n\t\t\t\t\treturn;\n\t\t\t\tresults = undefined;\n\t\t\t\tthis._completeResults = undefined;\n\t\t\t}\n\n\t\t\tif (!this._config.step && !this._config.chunk) {\n\t\t\t\tthis._completeResults.data = this._completeResults.data.concat(results.data);\n\t\t\t\tthis._completeResults.errors = this._completeResults.errors.concat(results.errors);\n\t\t\t\tthis._completeResults.meta = results.meta;\n\t\t\t}\n\n\t\t\tif (finishedIncludingPreview && isFunction(this._config.complete) && (!results || !results.meta.aborted))\n\t\t\t\tthis._config.complete(this._completeResults);\n\n\t\t\tif (!finishedIncludingPreview && (!results || !results.meta.paused))\n\t\t\t\tthis._nextChunk();\n\n\t\t\treturn results;\n\t\t};\n\n\t\tthis._sendError = function(error)\n\t\t{\n\t\t\tif (isFunction(this._config.error))\n\t\t\t\tthis._config.error(error);\n\t\t\telse if (IS_PAPA_WORKER && this._config.error)\n\t\t\t{\n\t\t\t\tglobal.postMessage({\n\t\t\t\t\tworkerId: Papa.WORKER_ID,\n\t\t\t\t\terror: error,\n\t\t\t\t\tfinished: false\n\t\t\t\t});\n\t\t\t}\n\t\t};\n\n\t\tfunction replaceConfig(config)\n\t\t{\n\t\t\t// Deep-copy the config so we can edit it\n\t\t\tvar configCopy = copy(config);\n\t\t\tconfigCopy.chunkSize = parseInt(configCopy.chunkSize);\t// parseInt VERY important so we don't concatenate strings!\n\t\t\tif (!config.step && !config.chunk)\n\t\t\t\tconfigCopy.chunkSize = null;  // disable Range header if not streaming; bad values break IIS - see issue #196\n\t\t\tthis._handle = new ParserHandle(configCopy);\n\t\t\tthis._handle.streamer = this;\n\t\t\tthis._config = configCopy;\t// persist the copy to the caller\n\t\t}\n\t}\n\n\n\tfunction NetworkStreamer(config)\n\t{\n\t\tconfig = config || {};\n\t\tif (!config.chunkSize)\n\t\t\tconfig.chunkSize = Papa.RemoteChunkSize;\n\t\tChunkStreamer.call(this, config);\n\n\t\tvar xhr;\n\n\t\tif (IS_WORKER)\n\t\t{\n\t\t\tthis._nextChunk = function()\n\t\t\t{\n\t\t\t\tthis._readChunk();\n\t\t\t\tthis._chunkLoaded();\n\t\t\t};\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis._nextChunk = function()\n\t\t\t{\n\t\t\t\tthis._readChunk();\n\t\t\t};\n\t\t}\n\n\t\tthis.stream = function(url)\n\t\t{\n\t\t\tthis._input = url;\n\t\t\tthis._nextChunk();\t// Starts streaming\n\t\t};\n\n\t\tthis._readChunk = function()\n\t\t{\n\t\t\tif (this._finished)\n\t\t\t{\n\t\t\t\tthis._chunkLoaded();\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\txhr = new XMLHttpRequest();\n\t\t\t\n\t\t\tif (!IS_WORKER)\n\t\t\t{\n\t\t\t\txhr.onload = bindFunction(this._chunkLoaded, this);\n\t\t\t\txhr.onerror = bindFunction(this._chunkError, this);\n\t\t\t}\n\n\t\t\txhr.open(\"GET\", this._input, !IS_WORKER);\n\t\t\t\n\t\t\tif (this._config.chunkSize)\n\t\t\t{\n\t\t\t\tvar end = this._start + this._config.chunkSize - 1;\t// minus one because byte range is inclusive\n\t\t\t\txhr.setRequestHeader(\"Range\", \"bytes=\"+this._start+\"-\"+end);\n\t\t\t\txhr.setRequestHeader(\"If-None-Match\", \"webkit-no-cache\"); // https://bugs.webkit.org/show_bug.cgi?id=82672\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\txhr.send();\n\t\t\t}\n\t\t\tcatch (err) {\n\t\t\t\tthis._chunkError(err.message);\n\t\t\t}\n\n\t\t\tif (IS_WORKER && xhr.status == 0)\n\t\t\t\tthis._chunkError();\n\t\t\telse\n\t\t\t\tthis._start += this._config.chunkSize;\n\t\t}\n\n\t\tthis._chunkLoaded = function()\n\t\t{\n\t\t\tif (xhr.readyState != 4)\n\t\t\t\treturn;\n\n\t\t\tif (xhr.status < 200 || xhr.status >= 400)\n\t\t\t{\n\t\t\t\tthis._chunkError();\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis._finished = !this._config.chunkSize || this._start > getFileSize(xhr);\n\t\t\tthis.parseChunk(xhr.responseText);\n\t\t}\n\n\t\tthis._chunkError = function(errorMessage)\n\t\t{\n\t\t\tvar errorText = xhr.statusText || errorMessage;\n\t\t\tthis._sendError(errorText);\n\t\t}\n\n\t\tfunction getFileSize(xhr)\n\t\t{\n\t\t\tvar contentRange = xhr.getResponseHeader(\"Content-Range\");\n\t\t\treturn parseInt(contentRange.substr(contentRange.lastIndexOf(\"/\") + 1));\n\t\t}\n\t}\n\tNetworkStreamer.prototype = Object.create(ChunkStreamer.prototype);\n\tNetworkStreamer.prototype.constructor = NetworkStreamer;\n\n\n\tfunction FileStreamer(config)\n\t{\n\t\tconfig = config || {};\n\t\tif (!config.chunkSize)\n\t\t\tconfig.chunkSize = Papa.LocalChunkSize;\n\t\tChunkStreamer.call(this, config);\n\n\t\tvar reader, slice;\n\n\t\t// FileReader is better than FileReaderSync (even in worker) - see http://stackoverflow.com/q/24708649/1048862\n\t\t// But Firefox is a pill, too - see issue #76: https://github.com/mholt/PapaParse/issues/76\n\t\tvar usingAsyncReader = typeof FileReader !== 'undefined';\t// Safari doesn't consider it a function - see issue #105\n\n\t\tthis.stream = function(file)\n\t\t{\n\t\t\tthis._input = file;\n\t\t\tslice = file.slice || file.webkitSlice || file.mozSlice;\n\n\t\t\tif (usingAsyncReader)\n\t\t\t{\n\t\t\t\treader = new FileReader();\t\t// Preferred method of reading files, even in workers\n\t\t\t\treader.onload = bindFunction(this._chunkLoaded, this);\n\t\t\t\treader.onerror = bindFunction(this._chunkError, this);\n\t\t\t}\n\t\t\telse\n\t\t\t\treader = new FileReaderSync();\t// Hack for running in a web worker in Firefox\n\n\t\t\tthis._nextChunk();\t// Starts streaming\n\t\t};\n\n\t\tthis._nextChunk = function()\n\t\t{\n\t\t\tif (!this._finished && (!this._config.preview || this._rowCount < this._config.preview))\n\t\t\t\tthis._readChunk();\n\t\t}\n\n\t\tthis._readChunk = function()\n\t\t{\n\t\t\tvar input = this._input;\n\t\t\tif (this._config.chunkSize)\n\t\t\t{\n\t\t\t\tvar end = Math.min(this._start + this._config.chunkSize, this._input.size);\n\t\t\t\tinput = slice.call(input, this._start, end);\n\t\t\t}\n\t\t\tvar txt = reader.readAsText(input, this._config.encoding);\n\t\t\tif (!usingAsyncReader)\n\t\t\t\tthis._chunkLoaded({ target: { result: txt } });\t// mimic the async signature\n\t\t}\n\n\t\tthis._chunkLoaded = function(event)\n\t\t{\n\t\t\t// Very important to increment start each time before handling results\n\t\t\tthis._start += this._config.chunkSize;\n\t\t\tthis._finished = !this._config.chunkSize || this._start >= this._input.size;\n\t\t\tthis.parseChunk(event.target.result);\n\t\t}\n\n\t\tthis._chunkError = function()\n\t\t{\n\t\t\tthis._sendError(reader.error);\n\t\t}\n\n\t}\n\tFileStreamer.prototype = Object.create(ChunkStreamer.prototype);\n\tFileStreamer.prototype.constructor = FileStreamer;\n\n\n\tfunction StringStreamer(config)\n\t{\n\t\tconfig = config || {};\n\t\tChunkStreamer.call(this, config);\n\n\t\tvar string;\n\t\tvar remaining;\n\t\tthis.stream = function(s)\n\t\t{\n\t\t\tstring = s;\n\t\t\tremaining = s;\n\t\t\treturn this._nextChunk();\n\t\t}\n\t\tthis._nextChunk = function()\n\t\t{\n\t\t\tif (this._finished) return;\n\t\t\tvar size = this._config.chunkSize;\n\t\t\tvar chunk = size ? remaining.substr(0, size) : remaining;\n\t\t\tremaining = size ? remaining.substr(size) : '';\n\t\t\tthis._finished = !remaining;\n\t\t\treturn this.parseChunk(chunk);\n\t\t}\n\t}\n\tStringStreamer.prototype = Object.create(StringStreamer.prototype);\n\tStringStreamer.prototype.constructor = StringStreamer;\n\n\n\n\t// Use one ParserHandle per entire CSV file or string\n\tfunction ParserHandle(_config)\n\t{\n\t\t// One goal is to minimize the use of regular expressions...\n\t\tvar FLOAT = /^\\s*-?(\\d*\\.?\\d+|\\d+\\.?\\d*)(e[-+]?\\d+)?\\s*$/i;\n\n\t\tvar self = this;\n\t\tvar _stepCounter = 0;\t// Number of times step was called (number of rows parsed)\n\t\tvar _input;\t\t\t\t// The input being parsed\n\t\tvar _parser;\t\t\t// The core parser being used\n\t\tvar _paused = false;\t// Whether we are paused or not\n\t\tvar _aborted = false;   // Whether the parser has aborted or not\n\t\tvar _delimiterError;\t// Temporary state between delimiter detection and processing results\n\t\tvar _fields = [];\t\t// Fields are from the header row of the input, if there is one\n\t\tvar _results = {\t\t// The last results returned from the parser\n\t\t\tdata: [],\n\t\t\terrors: [],\n\t\t\tmeta: {}\n\t\t};\n\n\t\tif (isFunction(_config.step))\n\t\t{\n\t\t\tvar userStep = _config.step;\n\t\t\t_config.step = function(results)\n\t\t\t{\n\t\t\t\t_results = results;\n\n\t\t\t\tif (needsHeaderRow())\n\t\t\t\t\tprocessResults();\n\t\t\t\telse\t// only call user's step function after header row\n\t\t\t\t{\n\t\t\t\t\tprocessResults();\n\n\t\t\t\t\t// It's possbile that this line was empty and there's no row here after all\n\t\t\t\t\tif (_results.data.length == 0)\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t_stepCounter += results.data.length;\n\t\t\t\t\tif (_config.preview && _stepCounter > _config.preview)\n\t\t\t\t\t\t_parser.abort();\n\t\t\t\t\telse\n\t\t\t\t\t\tuserStep(_results, self);\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\n\t\t/**\n\t\t * Parses input. Most users won't need, and shouldn't mess with, the baseIndex\n\t\t * and ignoreLastRow parameters. They are used by streamers (wrapper functions)\n\t\t * when an input comes in multiple chunks, like from a file.\n\t\t */\n\t\tthis.parse = function(input, baseIndex, ignoreLastRow)\n\t\t{\n\t\t\tif (!_config.newline)\n\t\t\t\t_config.newline = guessLineEndings(input);\n\n\t\t\t_delimiterError = false;\n\t\t\tif (!_config.delimiter)\n\t\t\t{\n\t\t\t\tvar delimGuess = guessDelimiter(input);\n\t\t\t\tif (delimGuess.successful)\n\t\t\t\t\t_config.delimiter = delimGuess.bestDelimiter;\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t_delimiterError = true;\t// add error after parsing (otherwise it would be overwritten)\n\t\t\t\t\t_config.delimiter = Papa.DefaultDelimiter;\n\t\t\t\t}\n\t\t\t\t_results.meta.delimiter = _config.delimiter;\n\t\t\t}\n\n\t\t\tvar parserConfig = copy(_config);\n\t\t\tif (_config.preview && _config.header)\n\t\t\t\tparserConfig.preview++;\t// to compensate for header row\n\n\t\t\t_input = input;\n\t\t\t_parser = new Parser(parserConfig);\n\t\t\t_results = _parser.parse(_input, baseIndex, ignoreLastRow);\n\t\t\tprocessResults();\n\t\t\treturn _paused ? { meta: { paused: true } } : (_results || { meta: { paused: false } });\n\t\t};\n\n\t\tthis.paused = function()\n\t\t{\n\t\t\treturn _paused;\n\t\t};\n\n\t\tthis.pause = function()\n\t\t{\n\t\t\t_paused = true;\n\t\t\t_parser.abort();\n\t\t\t_input = _input.substr(_parser.getCharIndex());\n\t\t};\n\n\t\tthis.resume = function()\n\t\t{\n\t\t\t_paused = false;\n\t\t\tself.streamer.parseChunk(_input);\n\t\t};\n\n\t\tthis.aborted = function () {\n\t\t\treturn _aborted;\n\t\t}\n\n\t\tthis.abort = function()\n\t\t{\n\t\t\t_aborted = true;\n\t\t\t_parser.abort();\n\t\t\t_results.meta.aborted = true;\n\t\t\tif (isFunction(_config.complete))\n\t\t\t\t_config.complete(_results);\n\t\t\t_input = \"\";\n\t\t};\n\n\t\tfunction processResults()\n\t\t{\n\t\t\tif (_results && _delimiterError)\n\t\t\t{\n\t\t\t\taddError(\"Delimiter\", \"UndetectableDelimiter\", \"Unable to auto-detect delimiting character; defaulted to '\"+Papa.DefaultDelimiter+\"'\");\n\t\t\t\t_delimiterError = false;\n\t\t\t}\n\n\t\t\tif (_config.skipEmptyLines)\n\t\t\t{\n\t\t\t\tfor (var i = 0; i < _results.data.length; i++)\n\t\t\t\t\tif (_results.data[i].length == 1 && _results.data[i][0] == \"\")\n\t\t\t\t\t\t_results.data.splice(i--, 1);\n\t\t\t}\n\n\t\t\tif (needsHeaderRow())\n\t\t\t\tfillHeaderFields();\n\n\t\t\treturn applyHeaderAndDynamicTyping();\n\t\t}\n\n\t\tfunction needsHeaderRow()\n\t\t{\n\t\t\treturn _config.header && _fields.length == 0;\n\t\t}\n\n\t\tfunction fillHeaderFields()\n\t\t{\n\t\t\tif (!_results)\n\t\t\t\treturn;\n\t\t\tfor (var i = 0; needsHeaderRow() && i < _results.data.length; i++)\n\t\t\t\tfor (var j = 0; j < _results.data[i].length; j++)\n\t\t\t\t\t_fields.push(_results.data[i][j]);\n\t\t\t_results.data.splice(0, 1);\n\t\t}\n\n\t\tfunction applyHeaderAndDynamicTyping()\n\t\t{\n\t\t\tif (!_results || (!_config.header && !_config.dynamicTyping))\n\t\t\t\treturn _results;\n\n\t\t\tfor (var i = 0; i < _results.data.length; i++)\n\t\t\t{\n\t\t\t\tvar row = {};\n\n\t\t\t\tfor (var j = 0; j < _results.data[i].length; j++)\n\t\t\t\t{\n\t\t\t\t\tif (_config.dynamicTyping)\n\t\t\t\t\t{\n\t\t\t\t\t\tvar value = _results.data[i][j];\n\t\t\t\t\t\tif (value == \"true\" || value == \"TRUE\")\n\t\t\t\t\t\t\t_results.data[i][j] = true;\n\t\t\t\t\t\telse if (value == \"false\" || value == \"FALSE\")\n\t\t\t\t\t\t\t_results.data[i][j] = false;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\t_results.data[i][j] = tryParseFloat(value);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (_config.header)\n\t\t\t\t\t{\n\t\t\t\t\t\tif (j >= _fields.length)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif (!row[\"__parsed_extra\"])\n\t\t\t\t\t\t\t\trow[\"__parsed_extra\"] = [];\n\t\t\t\t\t\t\trow[\"__parsed_extra\"].push(_results.data[i][j]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\trow[_fields[j]] = _results.data[i][j];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (_config.header)\n\t\t\t\t{\n\t\t\t\t\t_results.data[i] = row;\n\t\t\t\t\tif (j > _fields.length)\n\t\t\t\t\t\taddError(\"FieldMismatch\", \"TooManyFields\", \"Too many fields: expected \" + _fields.length + \" fields but parsed \" + j, i);\n\t\t\t\t\telse if (j < _fields.length)\n\t\t\t\t\t\taddError(\"FieldMismatch\", \"TooFewFields\", \"Too few fields: expected \" + _fields.length + \" fields but parsed \" + j, i);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (_config.header && _results.meta)\n\t\t\t\t_results.meta.fields = _fields;\n\t\t\treturn _results;\n\t\t}\n\n\t\tfunction guessDelimiter(input)\n\t\t{\n\t\t\tvar delimChoices = [\",\", \"\\t\", \"|\", \";\", Papa.RECORD_SEP, Papa.UNIT_SEP];\n\t\t\tvar bestDelim, bestDelta, fieldCountPrevRow;\n\n\t\t\tfor (var i = 0; i < delimChoices.length; i++)\n\t\t\t{\n\t\t\t\tvar delim = delimChoices[i];\n\t\t\t\tvar delta = 0, avgFieldCount = 0;\n\t\t\t\tfieldCountPrevRow = undefined;\n\n\t\t\t\tvar preview = new Parser({\n\t\t\t\t\tdelimiter: delim,\n\t\t\t\t\tpreview: 10\n\t\t\t\t}).parse(input);\n\n\t\t\t\tfor (var j = 0; j < preview.data.length; j++)\n\t\t\t\t{\n\t\t\t\t\tvar fieldCount = preview.data[j].length;\n\t\t\t\t\tavgFieldCount += fieldCount;\n\n\t\t\t\t\tif (typeof fieldCountPrevRow === 'undefined')\n\t\t\t\t\t{\n\t\t\t\t\t\tfieldCountPrevRow = fieldCount;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\telse if (fieldCount > 1)\n\t\t\t\t\t{\n\t\t\t\t\t\tdelta += Math.abs(fieldCount - fieldCountPrevRow);\n\t\t\t\t\t\tfieldCountPrevRow = fieldCount;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (preview.data.length > 0)\n\t\t\t\t\tavgFieldCount /= preview.data.length;\n\n\t\t\t\tif ((typeof bestDelta === 'undefined' || delta < bestDelta)\n\t\t\t\t\t&& avgFieldCount > 1.99)\n\t\t\t\t{\n\t\t\t\t\tbestDelta = delta;\n\t\t\t\t\tbestDelim = delim;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t_config.delimiter = bestDelim;\n\n\t\t\treturn {\n\t\t\t\tsuccessful: !!bestDelim,\n\t\t\t\tbestDelimiter: bestDelim\n\t\t\t}\n\t\t}\n\n\t\tfunction guessLineEndings(input)\n\t\t{\n\t\t\tinput = input.substr(0, 1024*1024);\t// max length 1 MB\n\n\t\t\tvar r = input.split('\\r');\n\n\t\t\tif (r.length == 1)\n\t\t\t\treturn '\\n';\n\n\t\t\tvar numWithN = 0;\n\t\t\tfor (var i = 0; i < r.length; i++)\n\t\t\t{\n\t\t\t\tif (r[i][0] == '\\n')\n\t\t\t\t\tnumWithN++;\n\t\t\t}\n\n\t\t\treturn numWithN >= r.length / 2 ? '\\r\\n' : '\\r';\n\t\t}\n\n\t\tfunction tryParseFloat(val)\n\t\t{\n\t\t\tvar isNumber = FLOAT.test(val);\n\t\t\treturn isNumber ? parseFloat(val) : val;\n\t\t}\n\n\t\tfunction addError(type, code, msg, row)\n\t\t{\n\t\t\t_results.errors.push({\n\t\t\t\ttype: type,\n\t\t\t\tcode: code,\n\t\t\t\tmessage: msg,\n\t\t\t\trow: row\n\t\t\t});\n\t\t}\n\t}\n\n\n\n\n\n\t/** The core parser implements speedy and correct CSV parsing */\n\tfunction Parser(config)\n\t{\n\t\t// Unpack the config object\n\t\tconfig = config || {};\n\t\tvar delim = config.delimiter;\n\t\tvar newline = config.newline;\n\t\tvar comments = config.comments;\n\t\tvar step = config.step;\n\t\tvar preview = config.preview;\n\t\tvar fastMode = config.fastMode;\n\n\t\t// Delimiter must be valid\n\t\tif (typeof delim !== 'string'\n\t\t\t|| Papa.BAD_DELIMITERS.indexOf(delim) > -1)\n\t\t\tdelim = \",\";\n\n\t\t// Comment character must be valid\n\t\tif (comments === delim)\n\t\t\tthrow \"Comment character same as delimiter\";\n\t\telse if (comments === true)\n\t\t\tcomments = \"#\";\n\t\telse if (typeof comments !== 'string'\n\t\t\t|| Papa.BAD_DELIMITERS.indexOf(comments) > -1)\n\t\t\tcomments = false;\n\n\t\t// Newline must be valid: \\r, \\n, or \\r\\n\n\t\tif (newline != '\\n' && newline != '\\r' && newline != '\\r\\n')\n\t\t\tnewline = '\\n';\n\n\t\t// We're gonna need these at the Parser scope\n\t\tvar cursor = 0;\n\t\tvar aborted = false;\n\n\t\tthis.parse = function(input, baseIndex, ignoreLastRow)\n\t\t{\n\t\t\t// For some reason, in Chrome, this speeds things up (!?)\n\t\t\tif (typeof input !== 'string')\n\t\t\t\tthrow \"Input must be a string\";\n\n\t\t\t// We don't need to compute some of these every time parse() is called,\n\t\t\t// but having them in a more local scope seems to perform better\n\t\t\tvar inputLen = input.length,\n\t\t\t\tdelimLen = delim.length,\n\t\t\t\tnewlineLen = newline.length,\n\t\t\t\tcommentsLen = comments.length;\n\t\t\tvar stepIsFunction = typeof step === 'function';\n\n\t\t\t// Establish starting state\n\t\t\tcursor = 0;\n\t\t\tvar data = [], errors = [], row = [], lastCursor = 0;\n\n\t\t\tif (!input)\n\t\t\t\treturn returnable();\n\n\t\t\tif (fastMode || (fastMode !== false && input.indexOf('\"') === -1))\n\t\t\t{\n\t\t\t\tvar rows = input.split(newline);\n\t\t\t\tfor (var i = 0; i < rows.length; i++)\n\t\t\t\t{\n\t\t\t\t\tvar row = rows[i];\n\t\t\t\t\tcursor += row.length;\n\t\t\t\t\tif (i !== rows.length - 1)\n\t\t\t\t\t\tcursor += newline.length;\n\t\t\t\t\telse if (ignoreLastRow)\n\t\t\t\t\t\treturn returnable();\n\t\t\t\t\tif (comments && row.substr(0, commentsLen) == comments)\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\tif (stepIsFunction)\n\t\t\t\t\t{\n\t\t\t\t\t\tdata = [];\n\t\t\t\t\t\tpushRow(row.split(delim));\n\t\t\t\t\t\tdoStep();\n\t\t\t\t\t\tif (aborted)\n\t\t\t\t\t\t\treturn returnable();\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t\tpushRow(row.split(delim));\n\t\t\t\t\tif (preview && i >= preview)\n\t\t\t\t\t{\n\t\t\t\t\t\tdata = data.slice(0, preview);\n\t\t\t\t\t\treturn returnable(true);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn returnable();\n\t\t\t}\n\n\t\t\tvar nextDelim = input.indexOf(delim, cursor);\n\t\t\tvar nextNewline = input.indexOf(newline, cursor);\n\n\t\t\t// Parser loop\n\t\t\tfor (;;)\n\t\t\t{\n\t\t\t\t// Field has opening quote\n\t\t\t\tif (input[cursor] == '\"')\n\t\t\t\t{\n\t\t\t\t\t// Start our search for the closing quote where the cursor is\n\t\t\t\t\tvar quoteSearch = cursor;\n\n\t\t\t\t\t// Skip the opening quote\n\t\t\t\t\tcursor++;\n\n\t\t\t\t\tfor (;;)\n\t\t\t\t\t{\n\t\t\t\t\t\t// Find closing quote\n\t\t\t\t\t\tvar quoteSearch = input.indexOf('\"', quoteSearch+1);\n\n\t\t\t\t\t\tif (quoteSearch === -1)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif (!ignoreLastRow) {\n\t\t\t\t\t\t\t\t// No closing quote... what a pity\n\t\t\t\t\t\t\t\terrors.push({\n\t\t\t\t\t\t\t\t\ttype: \"Quotes\",\n\t\t\t\t\t\t\t\t\tcode: \"MissingQuotes\",\n\t\t\t\t\t\t\t\t\tmessage: \"Quoted field unterminated\",\n\t\t\t\t\t\t\t\t\trow: data.length,\t// row has yet to be inserted\n\t\t\t\t\t\t\t\t\tindex: cursor\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn finish();\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (quoteSearch === inputLen-1)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// Closing quote at EOF\n\t\t\t\t\t\t\tvar value = input.substring(cursor, quoteSearch).replace(/\"\"/g, '\"');\n\t\t\t\t\t\t\treturn finish(value);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// If this quote is escaped, it's part of the data; skip it\n\t\t\t\t\t\tif (input[quoteSearch+1] == '\"')\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tquoteSearch++;\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (input[quoteSearch+1] == delim)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// Closing quote followed by delimiter\n\t\t\t\t\t\t\trow.push(input.substring(cursor, quoteSearch).replace(/\"\"/g, '\"'));\n\t\t\t\t\t\t\tcursor = quoteSearch + 1 + delimLen;\n\t\t\t\t\t\t\tnextDelim = input.indexOf(delim, cursor);\n\t\t\t\t\t\t\tnextNewline = input.indexOf(newline, cursor);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (input.substr(quoteSearch+1, newlineLen) === newline)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// Closing quote followed by newline\n\t\t\t\t\t\t\trow.push(input.substring(cursor, quoteSearch).replace(/\"\"/g, '\"'));\n\t\t\t\t\t\t\tsaveRow(quoteSearch + 1 + newlineLen);\n\t\t\t\t\t\t\tnextDelim = input.indexOf(delim, cursor);\t// because we may have skipped the nextDelim in the quoted field\n\n\t\t\t\t\t\t\tif (stepIsFunction)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tdoStep();\n\t\t\t\t\t\t\t\tif (aborted)\n\t\t\t\t\t\t\t\t\treturn returnable();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\tif (preview && data.length >= preview)\n\t\t\t\t\t\t\t\treturn returnable(true);\n\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Comment found at start of new line\n\t\t\t\tif (comments && row.length === 0 && input.substr(cursor, commentsLen) === comments)\n\t\t\t\t{\n\t\t\t\t\tif (nextNewline == -1)\t// Comment ends at EOF\n\t\t\t\t\t\treturn returnable();\n\t\t\t\t\tcursor = nextNewline + newlineLen;\n\t\t\t\t\tnextNewline = input.indexOf(newline, cursor);\n\t\t\t\t\tnextDelim = input.indexOf(delim, cursor);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Next delimiter comes before next newline, so we've reached end of field\n\t\t\t\tif (nextDelim !== -1 && (nextDelim < nextNewline || nextNewline === -1))\n\t\t\t\t{\n\t\t\t\t\trow.push(input.substring(cursor, nextDelim));\n\t\t\t\t\tcursor = nextDelim + delimLen;\n\t\t\t\t\tnextDelim = input.indexOf(delim, cursor);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// End of row\n\t\t\t\tif (nextNewline !== -1)\n\t\t\t\t{\n\t\t\t\t\trow.push(input.substring(cursor, nextNewline));\n\t\t\t\t\tsaveRow(nextNewline + newlineLen);\n\n\t\t\t\t\tif (stepIsFunction)\n\t\t\t\t\t{\n\t\t\t\t\t\tdoStep();\n\t\t\t\t\t\tif (aborted)\n\t\t\t\t\t\t\treturn returnable();\n\t\t\t\t\t}\n\n\t\t\t\t\tif (preview && data.length >= preview)\n\t\t\t\t\t\treturn returnable(true);\n\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\t\t\t}\n\n\n\t\t\treturn finish();\n\n\n\t\t\tfunction pushRow(row)\n\t\t\t{\n\t\t\t\tdata.push(row);\n\t\t\t\tlastCursor = cursor;\n\t\t\t}\n\n\t\t\t/**\n\t\t\t * Appends the remaining input from cursor to the end into\n\t\t\t * row, saves the row, calls step, and returns the results.\n\t\t\t */\n\t\t\tfunction finish(value)\n\t\t\t{\n\t\t\t\tif (ignoreLastRow)\n\t\t\t\t\treturn returnable();\n\t\t\t\tif (typeof value === 'undefined')\n\t\t\t\t\tvalue = input.substr(cursor);\n\t\t\t\trow.push(value);\n\t\t\t\tcursor = inputLen;\t// important in case parsing is paused\n\t\t\t\tpushRow(row);\n\t\t\t\tif (stepIsFunction)\n\t\t\t\t\tdoStep();\n\t\t\t\treturn returnable();\n\t\t\t}\n\n\t\t\t/**\n\t\t\t * Appends the current row to the results. It sets the cursor\n\t\t\t * to newCursor and finds the nextNewline. The caller should\n\t\t\t * take care to execute user's step function and check for\n\t\t\t * preview and end parsing if necessary.\n\t\t\t */\n\t\t\tfunction saveRow(newCursor)\n\t\t\t{\n\t\t\t\tcursor = newCursor;\n\t\t\t\tpushRow(row);\n\t\t\t\trow = [];\n\t\t\t\tnextNewline = input.indexOf(newline, cursor);\n\t\t\t}\n\n\t\t\t/** Returns an object with the results, errors, and meta. */\n\t\t\tfunction returnable(stopped)\n\t\t\t{\n\t\t\t\treturn {\n\t\t\t\t\tdata: data,\n\t\t\t\t\terrors: errors,\n\t\t\t\t\tmeta: {\n\t\t\t\t\t\tdelimiter: delim,\n\t\t\t\t\t\tlinebreak: newline,\n\t\t\t\t\t\taborted: aborted,\n\t\t\t\t\t\ttruncated: !!stopped,\n\t\t\t\t\t\tcursor: lastCursor + (baseIndex || 0)\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t/** Executes the user's step function and resets data & errors. */\n\t\t\tfunction doStep()\n\t\t\t{\n\t\t\t\tstep(returnable());\n\t\t\t\tdata = [], errors = [];\n\t\t\t}\n\t\t};\n\n\t\t/** Sets the abort flag */\n\t\tthis.abort = function()\n\t\t{\n\t\t\taborted = true;\n\t\t};\n\n\t\t/** Gets the cursor position */\n\t\tthis.getCharIndex = function()\n\t\t{\n\t\t\treturn cursor;\n\t\t};\n\t}\n\n\n\t// If you need to load Papa Parse asynchronously and you also need worker threads, hard-code\n\t// the script path here. See: https://github.com/mholt/PapaParse/issues/87#issuecomment-57885358\n\tfunction getScriptPath()\n\t{\n\t\tvar scripts = document.getElementsByTagName('script');\n\t\treturn scripts.length ? scripts[scripts.length - 1].src : '';\n\t}\n\n\tfunction newWorker()\n\t{\n\t\tif (!Papa.WORKERS_SUPPORTED)\n\t\t\treturn false;\n\t\tif (!LOADED_SYNC && Papa.SCRIPT_PATH === null)\n\t\t\tthrow new Error(\n\t\t\t\t'Script path cannot be determined automatically when Papa Parse is loaded asynchronously. ' +\n\t\t\t\t'You need to set Papa.SCRIPT_PATH manually.'\n\t\t\t);\n\t\tvar workerUrl = Papa.SCRIPT_PATH || AUTO_SCRIPT_PATH;\n\t\t// Append \"papaworker\" to the search string to tell papaparse that this is our worker.\n\t\tworkerUrl += (workerUrl.indexOf('?') !== -1 ? '&' : '?') + 'papaworker';\n\t\tvar w = new global.Worker(workerUrl);\n\t\tw.onmessage = mainThreadReceivedMessage;\n\t\tw.id = workerIdCounter++;\n\t\tworkers[w.id] = w;\n\t\treturn w;\n\t}\n\n\t/** Callback when main thread receives a message */\n\tfunction mainThreadReceivedMessage(e)\n\t{\n\t\tvar msg = e.data;\n\t\tvar worker = workers[msg.workerId];\n\t\tvar aborted = false;\n\n\t\tif (msg.error)\n\t\t\tworker.userError(msg.error, msg.file);\n\t\telse if (msg.results && msg.results.data)\n\t\t{\n\t\t\tvar abort = function() {\n\t\t\t\taborted = true;\n\t\t\t\tcompleteWorker(msg.workerId, { data: [], errors: [], meta: { aborted: true } });\n\t\t\t};\n\n\t\t\tvar handle = {\n\t\t\t\tabort: abort,\n\t\t\t\tpause: notImplemented,\n\t\t\t\tresume: notImplemented\n\t\t\t};\n\n\t\t\tif (isFunction(worker.userStep))\n\t\t\t{\n\t\t\t\tfor (var i = 0; i < msg.results.data.length; i++)\n\t\t\t\t{\n\t\t\t\t\tworker.userStep({\n\t\t\t\t\t\tdata: [msg.results.data[i]],\n\t\t\t\t\t\terrors: msg.results.errors,\n\t\t\t\t\t\tmeta: msg.results.meta\n\t\t\t\t\t}, handle);\n\t\t\t\t\tif (aborted)\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tdelete msg.results;\t// free memory ASAP\n\t\t\t}\n\t\t\telse if (isFunction(worker.userChunk))\n\t\t\t{\n\t\t\t\tworker.userChunk(msg.results, handle, msg.file);\n\t\t\t\tdelete msg.results;\n\t\t\t}\n\t\t}\n\n\t\tif (msg.finished && !aborted)\n\t\t\tcompleteWorker(msg.workerId, msg.results);\n\t}\n\n\tfunction completeWorker(workerId, results) {\n\t\tvar worker = workers[workerId];\n\t\tif (isFunction(worker.userComplete))\n\t\t\tworker.userComplete(results);\n\t\tworker.terminate();\n\t\tdelete workers[workerId];\n\t}\n\n\tfunction notImplemented() {\n\t\tthrow \"Not implemented.\";\n\t}\n\n\t/** Callback when worker thread receives a message */\n\tfunction workerThreadReceivedMessage(e)\n\t{\n\t\tvar msg = e.data;\n\n\t\tif (typeof Papa.WORKER_ID === 'undefined' && msg)\n\t\t\tPapa.WORKER_ID = msg.workerId;\n\n\t\tif (typeof msg.input === 'string')\n\t\t{\n\t\t\tglobal.postMessage({\n\t\t\t\tworkerId: Papa.WORKER_ID,\n\t\t\t\tresults: Papa.parse(msg.input, msg.config),\n\t\t\t\tfinished: true\n\t\t\t});\n\t\t}\n\t\telse if ((global.File && msg.input instanceof File) || msg.input instanceof Object)\t// thank you, Safari (see issue #106)\n\t\t{\n\t\t\tvar results = Papa.parse(msg.input, msg.config);\n\t\t\tif (results)\n\t\t\t\tglobal.postMessage({\n\t\t\t\t\tworkerId: Papa.WORKER_ID,\n\t\t\t\t\tresults: results,\n\t\t\t\t\tfinished: true\n\t\t\t\t});\n\t\t}\n\t}\n\n\t/** Makes a deep copy of an array or object (mostly) */\n\tfunction copy(obj)\n\t{\n\t\tif (typeof obj !== 'object')\n\t\t\treturn obj;\n\t\tvar cpy = obj instanceof Array ? [] : {};\n\t\tfor (var key in obj)\n\t\t\tcpy[key] = copy(obj[key]);\n\t\treturn cpy;\n\t}\n\n\tfunction bindFunction(f, self)\n\t{\n\t\treturn function() { f.apply(self, arguments); };\n\t}\n\n\tfunction isFunction(func)\n\t{\n\t\treturn typeof func === 'function';\n\t}\n})(typeof window !== 'undefined' ? window : this);\n"]} | |
| /* Given a list of positions: | |
| ('long', 50, 09-01-2015, 09-30-2015) | |
| ('short', 100, 09-15-2015, 10-15-2015) | |
| ('long', 50, 11-01-2015, 11-15,2015) | |
| A stock like AAPL. | |
| 09-01 09-15 50 | |
| 09-15 09-30 -50 | |
| 09-30 10-15 -100 */ | |
| const Papa = require('papaparse'); | |
| const csv = 'type,shares,start,stop\nlong,50,09-01-2015,09-30-2015\nshort,50,09-01-2015,09-30-2015\nlong,50,9-15-2015,9-30-2015'; | |
| let data = Papa.parse(csv, {delimiter:',', header: true}).data; | |
| let p = []; | |
| for (let i = 0; i < data.length; i++) { | |
| const d = data[i]; | |
| p.push({ | |
| type: d.type, | |
| date: +(new Date(d.start)), | |
| shares: +d.shares, | |
| }); | |
| p.push({ | |
| type: d.type, | |
| date: +(new Date(d.stop)), | |
| shares: -d.shares, | |
| }); | |
| } | |
| p = p.sort((a, b) => a.date - b.date); | |
| let sum = 0; | |
| let dt = 0; | |
| let max = -Infinity; | |
| for (let i = 0; i < p.length - 1; i++) { | |
| sum += p[i].type === 'long' ? +p[i].shares : -p[i].shares; | |
| dt = (sum === 0) ? 0 : (dt + p[i+1].date - p[i].date); | |
| max = Math.max(sum, max, dt); | |
| } | |
| console.log('max', max / 1000 / 60 / 60, 'hrs'); | |
| ;}, 0) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "name": "requirebin-sketch", | |
| "version": "1.0.0", | |
| "dependencies": { | |
| "papaparse": "4.1.2" | |
| } | |
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <body> --> |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <head> --> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment