@lingk/sync 0.1.80 → 0.1.81

package/build/main.js

@@ -355,7 +355,7 @@ module.exports =
 	                    joinKeyResourceName = rsc.joinKeyResource;
 	
 	                    // joinKeyName coming from field on this resource
-	                    if (rsc.resourceLabel === rsc.joinKeyResource) {
+	                    if (rsc.resourceName === rsc.joinKeyResource) {
 	                      var joinKeyResource = dataSourceMetadata.find(function (r) {
 	                        return r.type === rsc.joinKeyResource;
 	                      });
@@ -400,9 +400,7 @@ module.exports =
 	                    joinType: rsc.joinType || 'LEFT JOIN'
 	                  }, rscResource.parentRef && { parentRef: rscResource.parentRef }, rsc.parameterFilters && { parameterFilters: rsc.parameterFilters }, {
 	                    level: rsc.level || (rscIndex === 0 ? 0 : 1)
-	                  }, primaryKeyResourceName && {
-	                    parentNameAndProvider: primaryKeyResourceName + '_' + resourceProvider
-	                  }));
+	                  }, rsc.parentNameAndProvider && { parentNameAndProvider: rsc.parentNameAndProvider }));
 	                }
 	              }); // end bundle.resource.forEach
 	
@@ -801,7 +799,7 @@ module.exports =
 	        isSelected = selectedValues && selectedValues.length > 0 && selectedValues.some(function (rsc) {
 	          return rsc[fieldPropLabel] === entity[fieldPropLabel] && (!(parents && rsc.parents) || JSON.stringify(rsc.parents) === JSON.stringify(parents)) && (!rsc.section || sectionLabel === rsc.section);
 	        });
-	
+	        //console.log(entity.name)
 	        sectionValues.push(Object.assign({}, entity, {
 	          title: title,
 	          section: sectionLabel,
@@ -819,11 +817,11 @@ module.exports =
 	        return sectionValues;
 	      }.bind(this);
 	
-	      var vals = [].concat(_toConsumableArray(values));
+	      var vals = values && [].concat(_toConsumableArray(values));
 	      if (sectionLabels) {
 	        var v = [];
 	        sectionLabels.forEach(function (s, i) {
-	          if (values[i] && values[i].length > 0) {
+	          if (values && values[i] && values[i].length > 0) {
 	            (function () {
 	              v = v.concat(sectionLabels[i]);
 	              var sectionValues = [];
@@ -838,7 +836,7 @@ module.exports =
 	      } else {
 	        (function () {
 	          var sectionValues = [];
-	          values.forEach(function (entity) {
+	          values && values.forEach(function (entity) {
 	            iterator(sectionValues, entity, '', 0, []);
 	          });
 	          vals = sectionValues;
@@ -1529,7 +1527,7 @@ module.exports =
 	} else {
 	  // By explicitly using `prop-types` you are opting into new production behavior.
 	  // http://fb.me/prop-types-in-prod
-	  module.exports = __webpack_require__(177)();
+	  module.exports = __webpack_require__(178)();
 	}
 
 
@@ -1551,11 +1549,11 @@ module.exports =
 	
 	var _propTypes2 = _interopRequireDefault(_propTypes);
 	
-	var _TransitionGroup = __webpack_require__(205);
+	var _TransitionGroup = __webpack_require__(206);
 	
 	var _TransitionGroup2 = _interopRequireDefault(_TransitionGroup);
 	
-	var _CSSTransitionGroupChild = __webpack_require__(204);
+	var _CSSTransitionGroupChild = __webpack_require__(205);
 	
 	var _CSSTransitionGroupChild2 = _interopRequireDefault(_CSSTransitionGroupChild);
 	
@@ -5104,6 +5102,7 @@ module.exports =
 	  value: true
 	});
 	exports.callGetMetadata = callGetMetadata;
+	exports.setCsvFields = setCsvFields;
 	exports.tryCheckConnection = tryCheckConnection;
 	exports.callGetProviderMetadata = callGetProviderMetadata;
 	exports.getOauthUrl = getOauthUrl;
@@ -5192,6 +5191,13 @@ module.exports =
 	  };
 	}
 	
+	function setCsvFields(metadata, mode, providerType) {
+	  return {
+	    type: types.FINISH_WIZARD_ENV_CHECK,
+	    data: { metadata: metadata, mode: mode, code: '200 OK', providerType: providerType }
+	  };
+	}
+	
 	// "fake" credentials for demo purposes
 	function isDemoCreds(creds, providerType) {
 	  if (creds && providerType) {
@@ -6863,16 +6869,22 @@ module.exports =
 	
 	var _reduxForm = __webpack_require__(2);
 	
-	var _reactDropzone = __webpack_require__(202);
+	var _reactDropzone = __webpack_require__(203);
 	
 	var _reactDropzone2 = _interopRequireDefault(_reactDropzone);
 	
+	var _papaparse = __webpack_require__(177);
+	
+	var _papaparse2 = _interopRequireDefault(_papaparse);
+	
 	var _clipboard = __webpack_require__(122);
 	
 	var _clipboard2 = _interopRequireDefault(_clipboard);
 	
 	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 	
+	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+	
 	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 	
 	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
@@ -6892,23 +6904,10 @@ module.exports =
 	      checking = props.checking,
 	      generateNewAdapterSecret = props.generateNewAdapterSecret,
 	      tenantKey = props.tenantKey,
-	      accountKey = props.accountKey;
+	      accountKey = props.accountKey,
+	      setCsvFields = props.setCsvFields;
 	
 	
-	  if (config.skipEnvStep) return _react2.default.createElement(
-	    'div',
-	    { className: 'env-section-body', style: { paddingBottom: 11 } },
-	    wizard[mode + 'Metadata'] ? _react2.default.createElement(
-	      'span',
-	      null,
-	      'Your Salesforce Org is connected. Click Inspect to explore your available Salesforce resources.'
-	    ) : _react2.default.createElement(
-	      'span',
-	      null,
-	      'Your Salesforce Org is not connected. Please revoke all Oauth grants and reauthorize this managed package.'
-	    )
-	  );
-	
 	  var Button = inputs.Button;
 	  var Spinner = inputs.Spinner;
 	
@@ -6960,7 +6959,7 @@ module.exports =
 	        return getOauthUrl(urlType, mode);
 	      },
 	      mode: mode, inputs: inputs, checking: checking }) : isSFTP ? _react2.default.createElement(SFTP, { step: step, wizard: wizard, onCheck: check,
-	      mode: mode, checking: checking }) : _react2.default.createElement(
+	      mode: mode, checking: checking, setCsvFields: setCsvFields }) : _react2.default.createElement(
 	      'div',
 	      null,
 	      _react2.default.createElement(
@@ -7051,6 +7050,9 @@ module.exports =
 	var SFTP = function (_Component) {
 	  _inherits(SFTP, _Component);
 	
+	  // react-dropzone
+	  // papaparse
+	
 	  function SFTP() {
 	    _classCallCheck(this, SFTP);
 	
@@ -7064,9 +7066,42 @@ module.exports =
 	
 	  _createClass(SFTP, [{
 	    key: 'onDrop',
-	    value: function onDrop(files) {
-	      console.log(files);
-	      this.setState({ files: files });
+	    value: function onDrop(fs) {
+	      var _this2 = this;
+	
+	      var _props = this.props,
+	          setCsvFields = _props.setCsvFields,
+	          mode = _props.mode,
+	          step = _props.step,
+	          wizard = _props.wizard;
+	
+	      var m = wizard[mode + 'Metadata'] || [];
+	      var files = [].concat(_toConsumableArray(this.state.files));
+	      var counter = 0;
+	      fs.forEach(function (file) {
+	        _papaparse2.default.parse(file, {
+	          header: true,
+	          complete: function complete(result) {
+	            m = m.concat({
+	              name: file.name.split('.')[0],
+	              type: file.name.split('.')[0],
+	              properties: result.meta.fields.map(function (f) {
+	                return {
+	                  label: f,
+	                  name: f,
+	                  type: 'string'
+	                };
+	              })
+	            });
+	            files = files.concat(file);
+	            counter += 1;
+	            if (counter === fs.length) {
+	              _this2.setState({ files: files });
+	              setCsvFields(m, mode, step[mode + 'Provider']);
+	            }
+	          }
+	        });
+	      });
 	    }
 	  }, {
 	    key: 'render',
@@ -7091,9 +7126,9 @@ module.exports =
 	            )
 	          )
 	        ),
-	        _react2.default.createElement(
+	        files && files.length > 0 && _react2.default.createElement(
 	          'aside',
-	          { style: { marginLeft: 30 } },
+	          { style: { marginLeft: 30, display: 'inline-block' } },
 	          _react2.default.createElement(
 	            'h3',
 	            { style: { marginTop: 10 } },
@@ -7102,10 +7137,10 @@ module.exports =
 	          _react2.default.createElement(
 	            'ul',
 	            null,
-	            files.map(function (f) {
+	            files.map(function (f, i) {
 	              return _react2.default.createElement(
 	                'li',
-	                { key: f.name },
+	                { key: i },
 	                f.name,
 	                ' - ',
 	                f.size,
@@ -7254,42 +7289,42 @@ module.exports =
 	  function AdapterSecret() {
 	    _classCallCheck(this, AdapterSecret);
 	
-	    var _this2 = _possibleConstructorReturn(this, (AdapterSecret.__proto__ || Object.getPrototypeOf(AdapterSecret)).call(this));
+	    var _this3 = _possibleConstructorReturn(this, (AdapterSecret.__proto__ || Object.getPrototypeOf(AdapterSecret)).call(this));
 	
-	    _this2.copy = function () {
-	      var _this2$props = _this2.props,
-	          wizard = _this2$props.wizard,
-	          mode = _this2$props.mode;
+	    _this3.copy = function () {
+	      var _this3$props = _this3.props,
+	          wizard = _this3$props.wizard,
+	          mode = _this3$props.mode;
 	
 	      var secret = wizard.savedCredentials && wizard.savedCredentials[mode + 'AdapterSecret'];
 	      _clipboard2.default.copy({
 	        'text/plain': secret.credentials
 	      });
-	      _this2.setState({ secretCopied: true });
+	      _this3.setState({ secretCopied: true });
 	      setTimeout(function () {
-	        _this2.setState({ secretCopied: false });
+	        _this3.setState({ secretCopied: false });
 	      }, 4000);
 	    };
 	
-	    _this2.state = {
+	    _this3.state = {
 	      generating: false,
 	      secretCopied: false
 	    };
-	    return _this2;
+	    return _this3;
 	  }
 	
 	  _createClass(AdapterSecret, [{
 	    key: 'render',
 	    value: function render() {
-	      var _this3 = this;
+	      var _this4 = this;
 	
-	      var _props = this.props,
-	          wizard = _props.wizard,
-	          mode = _props.mode,
-	          inputs = _props.inputs,
-	          generateNewAdapterSecret = _props.generateNewAdapterSecret,
-	          tenantKey = _props.tenantKey,
-	          accountKey = _props.accountKey;
+	      var _props2 = this.props,
+	          wizard = _props2.wizard,
+	          mode = _props2.mode,
+	          inputs = _props2.inputs,
+	          generateNewAdapterSecret = _props2.generateNewAdapterSecret,
+	          tenantKey = _props2.tenantKey,
+	          accountKey = _props2.accountKey;
 	
 	      var secret = wizard.savedCredentials && wizard.savedCredentials[mode + 'AdapterSecret'];
 	      var Button = inputs.Button;
@@ -7357,7 +7392,7 @@ module.exports =
 	              icon: 'sync',
 	              iconAlign: 'left',
 	              onClick: function onClick() {
-	                _this3.setState({ generating: true });
+	                _this4.setState({ generating: true });
 	                generateNewAdapterSecret(mode);
 	              },
 	              style: { margin: '0 8px', marginBottom: 2, height: 30, lineHeight: '10px' } },
@@ -7378,12 +7413,12 @@ module.exports =
 	  function CustomSalesforceSettings() {
 	    _classCallCheck(this, CustomSalesforceSettings);
 	
-	    var _this4 = _possibleConstructorReturn(this, (CustomSalesforceSettings.__proto__ || Object.getPrototypeOf(CustomSalesforceSettings)).call(this));
+	    var _this5 = _possibleConstructorReturn(this, (CustomSalesforceSettings.__proto__ || Object.getPrototypeOf(CustomSalesforceSettings)).call(this));
 	
-	    _this4.state = {
+	    _this5.state = {
 	      custom: false
 	    };
-	    return _this4;
+	    return _this5;
 	  }
 	
 	  _createClass(CustomSalesforceSettings, [{
@@ -7398,7 +7433,7 @@ module.exports =
 	  }, {
 	    key: 'render',
 	    value: function render() {
-	      var _this5 = this;
+	      var _this6 = this;
 	
 	      var inputs = this.props.inputs;
 	      var Radio = inputs.Radio;
@@ -7414,7 +7449,7 @@ module.exports =
 	        ),
 	        _react2.default.createElement('br', null),
 	        _react2.default.createElement(Radio, { onChange: function onChange() {
-	            return _this5.setState({ custom: false });
+	            return _this6.setState({ custom: false });
 	          },
 	          label: 'Default Batch Size (10,000)',
 	          checked: this.state.custom === false,
@@ -7422,7 +7457,7 @@ module.exports =
 	        }),
 	        _react2.default.createElement('br', null),
 	        _react2.default.createElement(Radio, { onChange: function onChange() {
-	            return _this5.setState({ custom: true });
+	            return _this6.setState({ custom: true });
 	          },
 	          label: 'Custom Batch Size',
 	          checked: this.state.custom === true,
@@ -8941,7 +8976,8 @@ module.exports =
 	                                  fieldPropLabel: 'label',
 	                                  selectedValues: [{
 	                                    label: rsc.primaryKeyName,
-	                                    parents: rsc.primaryKeyParents
+	                                    parents: rsc.primaryKeyParents,
+	                                    section: rsc.primaryKeyResource
 	                                  }],
 	                                  sectionLabelSuffix: 'Fields'
 	                                })
@@ -9904,11 +9940,11 @@ module.exports =
 	
 	var _moment2 = _interopRequireDefault(_moment);
 	
-	__webpack_require__(213);
+	__webpack_require__(214);
 	
 	__webpack_require__(172);
 	
-	var _rcTimePicker = __webpack_require__(193);
+	var _rcTimePicker = __webpack_require__(194);
 	
 	var _rcTimePicker2 = _interopRequireDefault(_rcTimePicker);
 	
@@ -10399,9 +10435,13 @@ module.exports =
 	          formValues = _props8.formValues;
 	
 	      var envName = formValues['environment'];
-	      console.log('gen gen', mode);
 	      actions.generateNewAdapterSecret(tenantId, accountId, envName, mode);
 	    }
+	  }, {
+	    key: 'setCsvFields',
+	    value: function setCsvFields(metadata, mode, providerType) {
+	      this.props.actions.setCsvFields(metadata, mode, providerType);
+	    }
 	  }, {
 	    key: 'render',
 	    value: function render() {
@@ -10571,7 +10611,8 @@ module.exports =
 	                      generateNewAdapterSecret: _this5.generateNewAdapterSecret.bind(_this5),
 	                      clickDirection: _this5.clickDirection.bind(_this5),
 	                      seeFields: _this5.seeFields.bind(_this5), check: _this5.check,
-	                      tenantKey: tenantKey, accountKey: accountKey })
+	                      tenantKey: tenantKey, accountKey: accountKey,
+	                      setCsvFields: _this5.setCsvFields.bind(_this5) })
 	                  )
 	                )
 	              );
@@ -12406,6 +12447,8 @@ module.exports =
 	  _createClass(SchemaStep, [{
 	    key: 'componentDidMount',
 	    value: function componentDidMount() {
+	      var _this2 = this;
+	
 	      var _props = this.props,
 	          step = _props.step,
 	          wizard = _props.wizard,
@@ -12417,6 +12460,10 @@ module.exports =
 	      if (!wizard.dataLoaded) {
 	        (0, _loadData2.default)(step, wizard, change, formValues, actions, isReverse);
 	      }
+	      var resourceGroups = [].concat(_toConsumableArray(formValues['resourceGroups']));
+	      resourceGroups.forEach(function (rg, i) {
+	        _this2.assignAllParents(i);
+	      });
 	    }
 	  }, {
 	    key: 'openConnectionModal',
@@ -12637,6 +12684,8 @@ module.exports =
 	            break;
 	          }
 	        }
+	        console.log(eachR.parentNameAndProvider);
+	        //console.log(`${newParent}_${newParentProvider}`.toLowerCase())
 	        if (newParent && newParentProvider && (newParent + '_' + newParentProvider).toLowerCase() !== (eachR.parentNameAndProvider && eachR.parentNameAndProvider.toLowerCase())) {
 	          eachR.primaryKeyResource = newParent;
 	          eachR.parentNameAndProvider = newParent + '_' + newParentProvider;
@@ -12714,7 +12763,7 @@ module.exports =
 	  }, {
 	    key: 'render',
 	    value: function render() {
-	      var _this2 = this;
+	      var _this3 = this;
 	
 	      var _props14 = this.props,
 	          inputs = _props14.inputs,
@@ -12804,7 +12853,7 @@ module.exports =
 	            bundleIndex: this.state.selectedBundleIndex,
 	            sourceSchema: sourceSchema, destinationSchema: destinationSchema,
 	            update: function update() {
-	              return _this2.forceUpdate();
+	              return _this3.forceUpdate();
 	            },
 	            direction: formValues.direction
 	          })
@@ -13959,7 +14008,7 @@ module.exports =
 	
 	var _react2 = _interopRequireDefault(_react);
 	
-	var _redux = __webpack_require__(214);
+	var _redux = __webpack_require__(215);
 	
 	var _reactRedux = __webpack_require__(65);
 	
@@ -15501,6 +15550,1601 @@ module.exports =
 
 /***/ },
 /* 177 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
+		Papa Parse
+		v4.3.6
+		https://github.com/mholt/PapaParse
+		License: MIT
+	*/
+	(function(root, factory)
+	{
+		if (true)
+		{
+			// AMD. Register as an anonymous module.
+			!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+		}
+		else if (typeof module === 'object' && typeof exports !== 'undefined')
+		{
+			// Node. Does not work with strict CommonJS, but
+			// only CommonJS-like environments that support module.exports,
+			// like Node.
+			module.exports = factory();
+		}
+		else
+		{
+			// Browser globals (root is window)
+			root.Papa = factory();
+		}
+	}(this, function()
+	{
+		'use strict';
+	
+		var global = (function () {
+			// alternative method, similar to `Function('return this')()`
+			// but without using `eval` (which is disabled when
+			// using Content Security Policy).
+	
+			if (typeof self !== 'undefined') { return self; }
+			if (typeof window !== 'undefined') { return window; }
+			if (typeof global !== 'undefined') { return global; }
+	
+			// When running tests none of the above have been defined
+			return {};
+		})();
+	
+	
+		var IS_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;
+		Papa.ReadableStreamStreamer = ReadableStreamStreamer;
+	
+		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 || {};
+			var dynamicTyping = _config.dynamicTyping || false;
+			if (isFunction(dynamicTyping)) {
+				_config.dynamicTypingFunction = dynamicTyping;
+				// Will be filled on first row call
+				dynamicTyping = {};
+			}
+			_config.dynamicTyping = dynamicTyping;
+	
+			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 (_input.readable === true && isFunction(_input.read) && isFunction(_input.on))
+			{
+				streamer = new ReadableStreamStreamer(_config);
+			}
+			else if ((global.File && _input instanceof File) || _input instanceof Object)	// ...Safari. (see issue #106)
+				streamer = new FileStreamer(_config);
+	
+			return streamer.stream(_input);
+		}
+	
+	
+	
+	
+	
+	
+		function JsonToCsv(_input, _config)
+		{
+			var _output = '';
+			var _fields = [];
+	
+			// Default configuration
+	
+			/** whether to surround every datum with quotes */
+			var _quotes = false;
+	
+			/** whether to write headers */
+			var _writeHeader = true;
+	
+			/** delimiting character */
+			var _delimiter = ',';
+	
+			/** newline character(s) */
+			var _newline = '\r\n';
+	
+			/** quote character */
+			var _quoteChar = '"';
+	
+			unpackConfig();
+	
+			var quoteCharRegex = new RegExp(_quoteChar, 'g');
+	
+			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.meta && _input.meta.fields;
+	
+					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;
+	
+				if (typeof _config.quoteChar === 'string')
+					_quoteChar = _config.quoteChar;
+	
+				if (typeof _config.header === 'boolean')
+					_writeHeader = _config.header;
+			}
+	
+	
+			/** 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 && _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;
+	
+					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(quoteCharRegex, _quoteChar+_quoteChar);
+	
+				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 ? _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._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, this._input);
+	
+				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 (this._config.withCredentials)
+				{
+					xhr.withCredentials = this._config.withCredentials;
+				}
+	
+				if (!IS_WORKER)
+				{
+					xhr.onload = bindFunction(this._chunkLoaded, this);
+					xhr.onerror = bindFunction(this._chunkError, this);
+				}
+	
+				xhr.open('GET', this._input, !IS_WORKER);
+				// Headers can only be set when once the request state is OPENED
+				if (this._config.downloadRequestHeaders)
+				{
+					var headers = this._config.downloadRequestHeaders;
+	
+					for (var headerName in headers)
+					{
+						xhr.setRequestHeader(headerName, headers[headerName]);
+					}
+				}
+	
+				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');
+				if (contentRange === null) { // no content range, then finish!
+						return -1;
+						}
+				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;
+	
+	
+		function ReadableStreamStreamer(config)
+		{
+			config = config || {};
+	
+			ChunkStreamer.call(this, config);
+	
+			var queue = [];
+			var parseOnData = true;
+	
+			this.stream = function(stream)
+			{
+				this._input = stream;
+	
+				this._input.on('data', this._streamData);
+				this._input.on('end', this._streamEnd);
+				this._input.on('error', this._streamError);
+			}
+	
+			this._nextChunk = function()
+			{
+				if (queue.length)
+				{
+					this.parseChunk(queue.shift());
+				}
+				else
+				{
+					parseOnData = true;
+				}
+			}
+	
+			this._streamData = bindFunction(function(chunk)
+			{
+				try
+				{
+					queue.push(typeof chunk === 'string' ? chunk : chunk.toString(this._config.encoding));
+	
+					if (parseOnData)
+					{
+						parseOnData = false;
+						this.parseChunk(queue.shift());
+					}
+				}
+				catch (error)
+				{
+					this._streamError(error);
+				}
+			}, this);
+	
+			this._streamError = bindFunction(function(error)
+			{
+				this._streamCleanUp();
+				this._sendError(error.message);
+			}, this);
+	
+			this._streamEnd = bindFunction(function()
+			{
+				this._streamCleanUp();
+				this._finished = true;
+				this._streamData('');
+			}, this);
+	
+			this._streamCleanUp = bindFunction(function()
+			{
+				this._input.removeListener('data', this._streamData);
+				this._input.removeListener('end', this._streamEnd);
+				this._input.removeListener('error', this._streamError);
+			}, this);
+		}
+		ReadableStreamStreamer.prototype = Object.create(ChunkStreamer.prototype);
+		ReadableStreamStreamer.prototype.constructor = ReadableStreamStreamer;
+	
+	
+		// 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, _config.newline, _config.skipEmptyLines);
+					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);
+			};
+	
+			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 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
+						return tryParseFloat(value);
+				}
+				return value;
+			}
+	
+			function applyHeaderAndDynamicTyping()
+			{
+				if (!_results || (!_config.header && !_config.dynamicTyping))
+					return _results;
+	
+				for (var i = 0; i < _results.data.length; i++)
+				{
+					var row = _config.header ? {} : [];
+	
+					for (var j = 0; j < _results.data[i].length; j++)
+					{
+						var field = j;
+						var value = _results.data[i][j];
+	
+						if (_config.header)
+							field = j >= _fields.length ? '__parsed_extra' : _fields[j];
+	
+						value = parseDynamic(field, value);
+	
+						if (field === '__parsed_extra')
+						{
+							row[field] = row[field] || [];
+							row[field].push(value);
+						}
+						else
+							row[field] = value;
+					}
+	
+					_results.data[i] = row;
+	
+					if (_config.header)
+					{
+						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, newline, skipEmptyLines)
+			{
+				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, emptyLinesCount = 0;
+					fieldCountPrevRow = undefined;
+	
+					var preview = new Parser({
+						delimiter: delim,
+						newline: newline,
+						preview: 10
+					}).parse(input);
+	
+					for (var j = 0; j < preview.data.length; j++)
+					{
+						if (skipEmptyLines && preview.data[j].length === 1 && preview.data[j][0].length === 0) {
+							emptyLinesCount++
+							continue
+						}
+						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 - 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)
+			{
+				input = input.substr(0, 1024*1024);	// max length 1 MB
+	
+				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 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;
+			var quoteChar = config.quoteChar || '"';
+	
+			// 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 = 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++)
+					{
+						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);
+				var quoteCharRegex = new RegExp(quoteChar+quoteChar, 'g');
+	
+				// Parser loop
+				for (;;)
+				{
+					// Field has opening quote
+					if (input[cursor] === quoteChar)
+					{
+						// 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(quoteChar, quoteSearch+1);
+	
+							//No other quotes are found - no other delimiters
+							if (quoteSearch === -1)
+							{
+								if (!ignoreLastRow) {
+									// No closing quote... what a pity
+									errors.push({
+										type: 'Quotes',
+										code: 'MissingQuotes',
+										message: 'Quoted field unterminated',
+										row: data.length,	// row has yet to be inserted
+										index: cursor
+									});
+								}
+								return finish();
+							}
+	
+							// Closing quote at EOF
+							if (quoteSearch === inputLen-1)
+							{
+								var value = input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar);
+								return finish(value);
+							}
+	
+							// If this quote is escaped, it's part of the data; skip it
+							if (input[quoteSearch+1] === quoteChar)
+							{
+								quoteSearch++;
+								continue;
+							}
+	
+							// Closing quote followed by delimiter
+							if (input[quoteSearch+1] === delim)
+							{
+								row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
+								cursor = quoteSearch + 1 + delimLen;
+								nextDelim = input.indexOf(delim, cursor);
+								nextNewline = input.indexOf(newline, cursor);
+								break;
+							}
+	
+							// Closing quote followed by newline
+							if (input.substr(quoteSearch+1, newlineLen) === newline)
+							{
+								row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
+								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;
+							}
+	
+	
+							// Checks for valid closing quotes are complete (escaped quotes or quote followed by EOF/delimiter/newline) -- assume these quotes are part of an invalid text string
+							errors.push({
+								type: 'Quotes',
+								code: 'InvalidQuotes',
+								message: 'Trailing quote on quoted field is malformed',
+								row: data.length,	// row has yet to be inserted
+								index: cursor
+							});
+	
+							quoteSearch++;
+							continue;
+	
+						}
+	
+						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';
+		}
+	
+		return Papa;
+	}));
+
+
+/***/ },
+/* 178 */
 /***/ function(module, exports, __webpack_require__) {
 
 	/**
@@ -15514,9 +17158,9 @@ module.exports =
 	
 	'use strict';
 	
-	var emptyFunction = __webpack_require__(179);
-	var invariant = __webpack_require__(180);
-	var ReactPropTypesSecret = __webpack_require__(178);
+	var emptyFunction = __webpack_require__(180);
+	var invariant = __webpack_require__(181);
+	var ReactPropTypesSecret = __webpack_require__(179);
 	
 	module.exports = function() {
 	  function shim(props, propName, componentName, location, propFullName, secret) {
@@ -15565,7 +17209,7 @@ module.exports =
 
 
 /***/ },
-/* 178 */
+/* 179 */
 /***/ function(module, exports) {
 
 	/**
@@ -15585,7 +17229,7 @@ module.exports =
 
 
 /***/ },
-/* 179 */
+/* 180 */
 /***/ function(module, exports) {
 
 	"use strict";
@@ -15628,7 +17272,7 @@ module.exports =
 	module.exports = emptyFunction;
 
 /***/ },
-/* 180 */
+/* 181 */
 /***/ function(module, exports, __webpack_require__) {
 
 	/**
@@ -15688,7 +17332,7 @@ module.exports =
 	module.exports = invariant;
 
 /***/ },
-/* 181 */
+/* 182 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -15713,7 +17357,7 @@ module.exports =
 	
 	var _addEventListener2 = _interopRequireDefault(_addEventListener);
 	
-	var _isWindow = __webpack_require__(183);
+	var _isWindow = __webpack_require__(184);
 	
 	var _isWindow2 = _interopRequireDefault(_isWindow);
 	
@@ -15847,7 +17491,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 182 */
+/* 183 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -15856,7 +17500,7 @@ module.exports =
 	  value: true
 	});
 	
-	var _Align = __webpack_require__(181);
+	var _Align = __webpack_require__(182);
 	
 	var _Align2 = _interopRequireDefault(_Align);
 	
@@ -15867,7 +17511,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 183 */
+/* 184 */
 /***/ function(module, exports) {
 
 	"use strict";
@@ -15884,7 +17528,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 184 */
+/* 185 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -15899,9 +17543,9 @@ module.exports =
 	
 	var _react2 = _interopRequireDefault(_react);
 	
-	var _ChildrenUtils = __webpack_require__(186);
+	var _ChildrenUtils = __webpack_require__(187);
 	
-	var _AnimateChild = __webpack_require__(185);
+	var _AnimateChild = __webpack_require__(186);
 	
 	var _AnimateChild2 = _interopRequireDefault(_AnimateChild);
 	
@@ -16220,7 +17864,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 185 */
+/* 186 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -16331,7 +17975,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 186 */
+/* 187 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -16453,16 +18097,16 @@ module.exports =
 	}
 
 /***/ },
-/* 187 */
+/* 188 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 	
 	// export this package's api
-	module.exports = __webpack_require__(184);
+	module.exports = __webpack_require__(185);
 
 /***/ },
-/* 188 */
+/* 189 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -16475,7 +18119,7 @@ module.exports =
 	
 	var _react2 = _interopRequireDefault(_react);
 	
-	var _Select = __webpack_require__(191);
+	var _Select = __webpack_require__(192);
 	
 	var _Select2 = _interopRequireDefault(_Select);
 	
@@ -16699,7 +18343,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 189 */
+/* 190 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -16895,7 +18539,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 190 */
+/* 191 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -16912,11 +18556,11 @@ module.exports =
 	
 	var _react2 = _interopRequireDefault(_react);
 	
-	var _Header = __webpack_require__(189);
+	var _Header = __webpack_require__(190);
 	
 	var _Header2 = _interopRequireDefault(_Header);
 	
-	var _Combobox = __webpack_require__(188);
+	var _Combobox = __webpack_require__(189);
 	
 	var _Combobox2 = _interopRequireDefault(_Combobox);
 	
@@ -17089,7 +18733,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 191 */
+/* 192 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -17250,7 +18894,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 192 */
+/* 193 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -17263,15 +18907,15 @@ module.exports =
 	
 	var _react2 = _interopRequireDefault(_react);
 	
-	var _rcTrigger = __webpack_require__(198);
+	var _rcTrigger = __webpack_require__(199);
 	
 	var _rcTrigger2 = _interopRequireDefault(_rcTrigger);
 	
-	var _Panel = __webpack_require__(190);
+	var _Panel = __webpack_require__(191);
 	
 	var _Panel2 = _interopRequireDefault(_Panel);
 	
-	var _placements = __webpack_require__(194);
+	var _placements = __webpack_require__(195);
 	
 	var _placements2 = _interopRequireDefault(_placements);
 	
@@ -17553,7 +19197,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 193 */
+/* 194 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -17562,7 +19206,7 @@ module.exports =
 	  value: true
 	});
 	
-	var _TimePicker = __webpack_require__(192);
+	var _TimePicker = __webpack_require__(193);
 	
 	var _TimePicker2 = _interopRequireDefault(_TimePicker);
 	
@@ -17572,7 +19216,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 194 */
+/* 195 */
 /***/ function(module, exports) {
 
 	'use strict';
@@ -17618,7 +19262,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 195 */
+/* 196 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -17639,15 +19283,15 @@ module.exports =
 	
 	var _reactDom2 = _interopRequireDefault(_reactDom);
 	
-	var _rcAlign = __webpack_require__(182);
+	var _rcAlign = __webpack_require__(183);
 	
 	var _rcAlign2 = _interopRequireDefault(_rcAlign);
 	
-	var _rcAnimate = __webpack_require__(187);
+	var _rcAnimate = __webpack_require__(188);
 	
 	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
 	
-	var _PopupInner = __webpack_require__(196);
+	var _PopupInner = __webpack_require__(197);
 	
 	var _PopupInner2 = _interopRequireDefault(_PopupInner);
 	
@@ -17849,7 +19493,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 196 */
+/* 197 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -17906,7 +19550,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 197 */
+/* 198 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -17927,7 +19571,7 @@ module.exports =
 	
 	var _reactDom2 = _interopRequireDefault(_reactDom);
 	
-	var _contains = __webpack_require__(200);
+	var _contains = __webpack_require__(201);
 	
 	var _contains2 = _interopRequireDefault(_contains);
 	
@@ -17935,13 +19579,13 @@ module.exports =
 	
 	var _addEventListener2 = _interopRequireDefault(_addEventListener);
 	
-	var _Popup = __webpack_require__(195);
+	var _Popup = __webpack_require__(196);
 	
 	var _Popup2 = _interopRequireDefault(_Popup);
 	
-	var _utils = __webpack_require__(199);
+	var _utils = __webpack_require__(200);
 	
-	var _getContainerRenderMixin = __webpack_require__(201);
+	var _getContainerRenderMixin = __webpack_require__(202);
 	
 	var _getContainerRenderMixin2 = _interopRequireDefault(_getContainerRenderMixin);
 	
@@ -18405,15 +20049,15 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 198 */
+/* 199 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 	
-	module.exports = __webpack_require__(197);
+	module.exports = __webpack_require__(198);
 
 /***/ },
-/* 199 */
+/* 200 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -18453,7 +20097,7 @@ module.exports =
 	}
 
 /***/ },
-/* 200 */
+/* 201 */
 /***/ function(module, exports) {
 
 	"use strict";
@@ -18476,7 +20120,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 201 */
+/* 202 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -18581,7 +20225,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 202 */
+/* 203 */
 /***/ function(module, exports, __webpack_require__) {
 
 	(function webpackUniversalModuleDefinition(root, factory) {
@@ -19602,8 +21246,8 @@ module.exports =
 	//# sourceMappingURL=index.js.map
 
 /***/ },
-/* 203 */,
-/* 204 */
+/* 204 */,
+/* 205 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -19612,19 +21256,19 @@ module.exports =
 	
 	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
 	
-	var _addClass = __webpack_require__(206);
+	var _addClass = __webpack_require__(207);
 	
 	var _addClass2 = _interopRequireDefault(_addClass);
 	
-	var _removeClass = __webpack_require__(208);
+	var _removeClass = __webpack_require__(209);
 	
 	var _removeClass2 = _interopRequireDefault(_removeClass);
 	
-	var _requestAnimationFrame = __webpack_require__(210);
+	var _requestAnimationFrame = __webpack_require__(211);
 	
 	var _requestAnimationFrame2 = _interopRequireDefault(_requestAnimationFrame);
 	
-	var _properties = __webpack_require__(209);
+	var _properties = __webpack_require__(210);
 	
 	var _react = __webpack_require__(1);
 	
@@ -19837,7 +21481,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 205 */
+/* 206 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -19858,11 +21502,11 @@ module.exports =
 	
 	var _propTypes2 = _interopRequireDefault(_propTypes);
 	
-	var _warning = __webpack_require__(212);
+	var _warning = __webpack_require__(213);
 	
 	var _warning2 = _interopRequireDefault(_warning);
 	
-	var _ChildMapping = __webpack_require__(211);
+	var _ChildMapping = __webpack_require__(212);
 	
 	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 	
@@ -20114,7 +21758,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 206 */
+/* 207 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -20124,7 +21768,7 @@ module.exports =
 	});
 	exports.default = addClass;
 	
-	var _hasClass = __webpack_require__(207);
+	var _hasClass = __webpack_require__(208);
 	
 	var _hasClass2 = _interopRequireDefault(_hasClass);
 	
@@ -20136,7 +21780,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 207 */
+/* 208 */
 /***/ function(module, exports) {
 
 	"use strict";
@@ -20151,7 +21795,7 @@ module.exports =
 	module.exports = exports["default"];
 
 /***/ },
-/* 208 */
+/* 209 */
 /***/ function(module, exports) {
 
 	'use strict';
@@ -20161,7 +21805,7 @@ module.exports =
 	};
 
 /***/ },
-/* 209 */
+/* 210 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -20276,7 +21920,7 @@ module.exports =
 	}
 
 /***/ },
-/* 210 */
+/* 211 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -20334,7 +21978,7 @@ module.exports =
 	module.exports = exports['default'];
 
 /***/ },
-/* 211 */
+/* 212 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -20430,7 +22074,7 @@ module.exports =
 	}
 
 /***/ },
-/* 212 */
+/* 213 */
 /***/ function(module, exports, __webpack_require__) {
 
 	/**
@@ -20496,13 +22140,13 @@ module.exports =
 
 
 /***/ },
-/* 213 */
+/* 214 */
 /***/ function(module, exports) {
 
 	module.exports = require("moment-timezone");
 
 /***/ },
-/* 214 */
+/* 215 */
 /***/ function(module, exports) {
 
 	module.exports = require("redux");