csvtojson - npm Package Compare versions

Comparing version 2.0.8 to 2.0.10

.ts-node/4c960549d...b167a1060208a0fdf57d39dc695ae209e0c9.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var CSVError_1 = __importDefault(require("./CSVError"));
+var set_1 = __importDefault(require("lodash/set"));
+var numReg = /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/;
+function default_1(csvRows, conv) {
+    var res = [];
+    for (var i = 0, len = csvRows.length; i < len; i++) {
+        var r = processRow(csvRows[i], conv, i);
+        if (r) {
+            res.push(r);
+        }
+    }
+    return res;
+}
+exports.default = default_1;
+;
+function processRow(row, conv, index) {
+    if (conv.parseParam.checkColumn && conv.parseRuntime.headers && row.length !== conv.parseRuntime.headers.length) {
+        throw (CSVError_1.default.column_mismatched(conv.parseRuntime.parsedLineNumber + index));
+    }
+    var headRow = conv.parseRuntime.headers || [];
+    var resultRow = convertRowToJson(row, headRow, conv);
+    if (resultRow) {
+        return resultRow;
+    }
+    else {
+        return null;
+    }
+}
+function convertRowToJson(row, headRow, conv) {
+    var hasValue = false;
+    var resultRow = {};
+    for (var i = 0, len = row.length; i < len; i++) {
+        var item = row[i];
+        if (conv.parseParam.ignoreEmpty && item === '') {
+            continue;
+        }
+        hasValue = true;
+        var head = headRow[i];
+        if (!head || head === "") {
+            head = headRow[i] = "field" + (i + 1);
+        }
+        var convFunc = getConvFunc(head, i, conv);
+        if (convFunc) {
+            var convRes = convFunc(item, head, resultRow, row, i);
+            if (convRes !== undefined) {
+                setPath(resultRow, head, convRes, conv, i);
+            }
+        }
+        else {
+            // var flag = getFlag(head, i, param);
+            // if (flag === 'omit') {
+            //   continue;
+            // }
+            if (conv.parseParam.checkType) {
+                var convertFunc = checkType(item, head, i, conv);
+                item = convertFunc(item);
+            }
+            if (item !== undefined) {
+                setPath(resultRow, head, item, conv, i);
+            }
+        }
+    }
+    if (hasValue) {
+        return resultRow;
+    }
+    else {
+        return null;
+    }
+}
+var builtInConv = {
+    "string": stringType,
+    "number": numberType,
+    "omit": function () { }
+};
+function getConvFunc(head, i, conv) {
+    if (conv.parseRuntime.columnConv[i] !== undefined) {
+        return conv.parseRuntime.columnConv[i];
+    }
+    else {
+        var flag = conv.parseParam.colParser[head];
+        if (flag === undefined) {
+            return conv.parseRuntime.columnConv[i] = null;
+        }
+        if (typeof flag === "object") {
+            flag = flag.cellParser || "string";
+        }
+        if (typeof flag === "string") {
+            flag = flag.trim().toLowerCase();
+            var builtInFunc = builtInConv[flag];
+            if (builtInFunc) {
+                return conv.parseRuntime.columnConv[i] = builtInFunc;
+            }
+            else {
+                return conv.parseRuntime.columnConv[i] = null;
+            }
+        }
+        else if (typeof flag === "function") {
+            return conv.parseRuntime.columnConv[i] = flag;
+        }
+        else {
+            return conv.parseRuntime.columnConv[i] = null;
+        }
+    }
+}
+function setPath(resultJson, head, value, conv, headIdx) {
+    if (!conv.parseRuntime.columnValueSetter[headIdx]) {
+        if (conv.parseParam.flatKeys) {
+            conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;
+        }
+        else {
+            if (head.indexOf(".") > -1) {
+                var headArr = head.split(".");
+                var jsonHead = true;
+                while (headArr.length > 0) {
+                    var headCom = headArr.shift();
+                    if (headCom.length === 0) {
+                        jsonHead = false;
+                        break;
+                    }
+                }
+                if (!jsonHead || conv.parseParam.colParser[head] && conv.parseParam.colParser[head].flat) {
+                    conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;
+                }
+                else {
+                    conv.parseRuntime.columnValueSetter[headIdx] = jsonSetter;
+                }
+            }
+            else {
+                conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;
+            }
+        }
+    }
+    if (conv.parseParam.nullObject === true && value === "null") {
+        value = null;
+    }
+    conv.parseRuntime.columnValueSetter[headIdx](resultJson, head, value);
+    // flatSetter(resultJson, head, value);
+}
+function flatSetter(resultJson, head, value) {
+    resultJson[head] = value;
+}
+function jsonSetter(resultJson, head, value) {
+    set_1.default(resultJson, head, value);
+}
+function checkType(item, head, headIdx, conv) {
+    if (conv.parseRuntime.headerType[headIdx]) {
+        return conv.parseRuntime.headerType[headIdx];
+    }
+    else if (head.indexOf('number#!') > -1) {
+        return conv.parseRuntime.headerType[headIdx] = numberType;
+    }
+    else if (head.indexOf('string#!') > -1) {
+        return conv.parseRuntime.headerType[headIdx] = stringType;
+    }
+    else if (conv.parseParam.checkType) {
+        return conv.parseRuntime.headerType[headIdx] = dynamicType;
+    }
+    else {
+        return conv.parseRuntime.headerType[headIdx] = stringType;
+    }
+}
+function numberType(item) {
+    var rtn = parseFloat(item);
+    if (isNaN(rtn)) {
+        return item;
+    }
+    return rtn;
+}
+function stringType(item) {
+    return item.toString();
+}
+function dynamicType(item) {
+    var trimed = item.trim();
+    if (trimed === "") {
+        return stringType(item);
+    }
+    if (numReg.test(trimed)) {
+        return numberType(item);
+    }
+    else if (trimed.length === 5 && trimed.toLowerCase() === "false" || trimed.length === 4 && trimed.toLowerCase() === "true") {
+        return booleanType(item);
+    }
+    else if (trimed[0] === "{" && trimed[trimed.length - 1] === "}" || trimed[0] === "[" && trimed[trimed.length - 1] === "]") {
+        return jsonType(item);
+    }
+    else {
+        return stringType(item);
+    }
+}
+function booleanType(item) {
+    var trimed = item.trim();
+    if (trimed.length === 5 && trimed.toLowerCase() === "false") {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+function jsonType(item) {
+    try {
+        return JSON.parse(item);
+    }
+    catch (e) {
+        return item;
+    }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/lineToJson.ts","sources":["/Users/kxiang/work/projects/csv2json/src/lineToJson.ts"],"names":[],"mappings":"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","sourcesContent":["import { Converter } from \"./Converter\";\nimport CSVError from \"./CSVError\";\nimport { CellParser, ColumnParam } from \"./Parameters\";\nimport set from \"lodash/set\";\nimport { ParseRuntime } from \"./ParseRuntime\";\n\nvar numReg = /^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$/;\n\nexport default function (csvRows: string[][], conv: Converter): JSONResult[] {\n  const res: JSONResult[] = [];\n  for (let i = 0, len = csvRows.length; i < len; i++) {\n    const r = processRow(csvRows[i], conv, i);\n    if (r) {\n      res.push(r);\n    }\n  }\n  return res;\n};\nexport type JSONResult = {\n  [key: string]: any\n}\n\nfunction processRow(row: string[], conv: Converter, index): JSONResult | null {\n\n  if (conv.parseParam.checkColumn && conv.parseRuntime.headers && row.length !== conv.parseRuntime.headers.length) {\n    throw (CSVError.column_mismatched(conv.parseRuntime.parsedLineNumber + index))\n  }\n\n  const headRow = conv.parseRuntime.headers || [];\n  const resultRow = convertRowToJson(row, headRow, conv);\n  if (resultRow) {\n    return resultRow;\n  } else {\n    return null;\n  }\n}\n\nfunction convertRowToJson(row: string[], headRow: string[], conv: Converter): { [key: string]: any } | null {\n  let hasValue = false;\n  const resultRow = {};\n  \n  for (let i = 0, len = row.length; i < len; i++) {\n    let item = row[i];\n\n    if (conv.parseParam.ignoreEmpty && item === '') {\n      continue;\n    }\n    hasValue = true;\n\n    let head = headRow[i];\n    if (!head || head === \"\") {\n      head = headRow[i] = \"field\" + (i + 1);\n    }\n    const convFunc = getConvFunc(head, i, conv);\n    if (convFunc) {\n      const convRes = convFunc(item, head, resultRow, row, i);\n      if (convRes !== undefined) {\n        setPath(resultRow, head, convRes, conv,i);\n      }\n    } else {\n      // var flag = getFlag(head, i, param);\n      // if (flag === 'omit') {\n      //   continue;\n      // }\n      if (conv.parseParam.checkType) {\n        const convertFunc = checkType(item, head, i, conv);\n        item = convertFunc(item);\n      }\n      if (item !== undefined) {\n        setPath(resultRow, head, item, conv,i);\n      }\n    }\n  }\n  if (hasValue) {\n    return resultRow;\n  } else {\n    return null;\n  }\n}\n\nconst builtInConv: { [key: string]: CellParser } = {\n  \"string\": stringType,\n  \"number\": numberType,\n  \"omit\": function () { }\n}\nfunction getConvFunc(head: string, i: number, conv: Converter): CellParser | null {\n  if (conv.parseRuntime.columnConv[i] !== undefined) {\n    return conv.parseRuntime.columnConv[i];\n  } else {\n    let flag = conv.parseParam.colParser[head];\n    if (flag === undefined) {\n      return conv.parseRuntime.columnConv[i] = null;\n    }\n    if (typeof flag === \"object\") {\n      flag = (flag as ColumnParam).cellParser || \"string\";\n    }\n    if (typeof flag === \"string\") {\n      flag = flag.trim().toLowerCase();\n      const builtInFunc = builtInConv[flag];\n      if (builtInFunc) {\n        return conv.parseRuntime.columnConv[i] = builtInFunc;\n      } else {\n        return conv.parseRuntime.columnConv[i] = null;\n      }\n    } else if (typeof flag === \"function\") {\n      return conv.parseRuntime.columnConv[i] = flag;\n    } else {\n      return conv.parseRuntime.columnConv[i] = null;\n    }\n  }\n}\nfunction setPath(resultJson: any, head: string, value: any, conv: Converter,headIdx:number) {\n  if (!conv.parseRuntime.columnValueSetter[headIdx]) {\n    if (conv.parseParam.flatKeys) {\n      conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;\n    } else {\n      \n      if (head.indexOf(\".\") > -1) {\n        const headArr=head.split(\".\");\n        let jsonHead=true;\n        while(headArr.length>0){\n          const headCom=headArr.shift();\n          if (headCom!.length===0){\n            jsonHead=false;\n            break;\n          }\n        }\n        if (!jsonHead || conv.parseParam.colParser[head] && (conv.parseParam.colParser[head] as ColumnParam).flat) {\n          conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;\n        } else {\n          conv.parseRuntime.columnValueSetter[headIdx] = jsonSetter;\n        }\n      } else {\n        conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;\n      }\n    }\n  }\n  if (conv.parseParam.nullObject ===true && value ===\"null\"){\n    value=null;\n  }\n  conv.parseRuntime.columnValueSetter[headIdx](resultJson, head, value);\n  // flatSetter(resultJson, head, value);\n\n}\nfunction flatSetter(resultJson: any, head: string, value: any) {\n  resultJson[head] = value;\n}\nfunction jsonSetter(resultJson: any, head: string, value: any) {\n  set(resultJson, head, value);\n}\n\n\nfunction checkType(item: string, head: string, headIdx: number, conv: Converter): Function {\n  if (conv.parseRuntime.headerType[headIdx]) {\n    return conv.parseRuntime.headerType[headIdx];\n  } else if (head.indexOf('number#!') > -1) {\n    return conv.parseRuntime.headerType[headIdx] = numberType;\n  } else if (head.indexOf('string#!') > -1) {\n    return conv.parseRuntime.headerType[headIdx] = stringType;\n  } else if (conv.parseParam.checkType) {\n    return conv.parseRuntime.headerType[headIdx] = dynamicType;\n  } else {\n    return conv.parseRuntime.headerType[headIdx] = stringType;\n  }\n}\n\nfunction numberType(item) {\n  var rtn = parseFloat(item);\n  if (isNaN(rtn)) {\n    return item;\n  }\n  return rtn;\n}\n\nfunction stringType(item: string): string {\n  return item.toString();\n}\n\nfunction dynamicType(item) {\n  var trimed = item.trim();\n  if (trimed === \"\") {\n    return stringType(item);\n  }\n  if (numReg.test(trimed)) {\n    return numberType(item);\n  } else if (trimed.length === 5 && trimed.toLowerCase() === \"false\" || trimed.length === 4 && trimed.toLowerCase() === \"true\") {\n    return booleanType(item);\n  } else if (trimed[0] === \"{\" && trimed[trimed.length - 1] === \"}\" || trimed[0] === \"[\" && trimed[trimed.length - 1] === \"]\") {\n    return jsonType(item);\n  } else {\n    return stringType(item);\n  }\n}\n\nfunction booleanType(item) {\n  var trimed = item.trim();\n  if (trimed.length === 5 && trimed.toLowerCase() === \"false\") {\n    return false;\n  } else {\n    return true;\n  }\n}\n\nfunction jsonType(item) {\n  try {\n    return JSON.parse(item);\n  } catch (e) {\n    return item;\n  }\n}\n"]}

.ts-node/4c960549d...1828a2caaa54a764fc152183ad640d1d66be.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function initParseRuntime(converter) {
+    var params = converter.parseParam;
+    var rtn = {
+        needProcessIgnoreColumn: false,
+        needProcessIncludeColumn: false,
+        selectedColumns: undefined,
+        ended: false,
+        hasError: false,
+        error: undefined,
+        delimiter: converter.parseParam.delimiter,
+        eol: converter.parseParam.eol,
+        columnConv: [],
+        headerType: [],
+        headerTitle: [],
+        headerFlag: [],
+        headers: undefined,
+        started: false,
+        parsedLineNumber: 0,
+        columnValueSetter: [],
+    };
+    if (params.ignoreColumns) {
+        rtn.needProcessIgnoreColumn = true;
+    }
+    if (params.includeColumns) {
+        rtn.needProcessIncludeColumn = true;
+    }
+    return rtn;
+}
+exports.initParseRuntime = initParseRuntime;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/4c960549d...ac032beb92732a7fc3a93a7da308df59074b.js

+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Processor_1 = require("./Processor");
+var bluebird_1 = __importDefault(require("bluebird"));
+var dataClean_1 = require("./dataClean");
+var getEol_1 = __importDefault(require("./getEol"));
+var fileline_1 = require("./fileline");
+var util_1 = require("./util");
+var rowSplit_1 = require("./rowSplit");
+var lineToJson_1 = __importDefault(require("./lineToJson"));
+var CSVError_1 = __importDefault(require("./CSVError"));
+var ProcessorLocal = /** @class */ (function (_super) {
+    __extends(ProcessorLocal, _super);
+    function ProcessorLocal() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.rowSplit = new rowSplit_1.RowSplit(_this.converter);
+        _this.eolEmitted = false;
+        _this._needEmitEol = undefined;
+        _this.headEmitted = false;
+        _this._needEmitHead = undefined;
+        return _this;
+    }
+    ProcessorLocal.prototype.flush = function () {
+        var _this = this;
+        if (this.runtime.csvLineBuffer && this.runtime.csvLineBuffer.length > 0) {
+            var buf = this.runtime.csvLineBuffer;
+            this.runtime.csvLineBuffer = undefined;
+            return this.process(buf, true)
+                .then(function (res) {
+                if (_this.runtime.csvLineBuffer && _this.runtime.csvLineBuffer.length > 0) {
+                    return bluebird_1.default.reject(CSVError_1.default.unclosed_quote(_this.runtime.parsedLineNumber, _this.runtime.csvLineBuffer.toString()));
+                }
+                else {
+                    return bluebird_1.default.resolve(res);
+                }
+            });
+        }
+        else {
+            return bluebird_1.default.resolve([]);
+        }
+    };
+    ProcessorLocal.prototype.destroy = function () {
+        return bluebird_1.default.resolve();
+    };
+    Object.defineProperty(ProcessorLocal.prototype, "needEmitEol", {
+        get: function () {
+            if (this._needEmitEol === undefined) {
+                this._needEmitEol = this.converter.listeners("eol").length > 0;
+            }
+            return this._needEmitEol;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ProcessorLocal.prototype, "needEmitHead", {
+        get: function () {
+            if (this._needEmitHead === undefined) {
+                this._needEmitHead = this.converter.listeners("header").length > 0;
+            }
+            return this._needEmitHead;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ProcessorLocal.prototype.process = function (chunk, finalChunk) {
+        var _this = this;
+        if (finalChunk === void 0) { finalChunk = false; }
+        var csvString;
+        if (finalChunk) {
+            csvString = chunk.toString();
+        }
+        else {
+            csvString = dataClean_1.prepareData(chunk, this.converter.parseRuntime);
+        }
+        return bluebird_1.default.resolve()
+            .then(function () {
+            if (_this.runtime.preRawDataHook) {
+                return _this.runtime.preRawDataHook(csvString);
+            }
+            else {
+                return csvString;
+            }
+        })
+            .then(function (csv) {
+            if (csv && csv.length > 0) {
+                return _this.processCSV(csv, finalChunk);
+            }
+            else {
+                return bluebird_1.default.resolve([]);
+            }
+        });
+    };
+    ProcessorLocal.prototype.processCSV = function (csv, finalChunk) {
+        var _this = this;
+        var params = this.params;
+        var runtime = this.runtime;
+        if (!runtime.eol) {
+            getEol_1.default(csv, runtime);
+        }
+        if (this.needEmitEol && !this.eolEmitted && runtime.eol) {
+            this.converter.emit("eol", runtime.eol);
+            this.eolEmitted = true;
+        }
+        // trim csv file has initial blank lines.
+        if (params.ignoreEmpty && !runtime.started) {
+            csv = util_1.trimLeft(csv);
+        }
+        var stringToLineResult = fileline_1.stringToLines(csv, runtime);
+        if (!finalChunk) {
+            this.prependLeftBuf(util_1.bufFromString(stringToLineResult.partial));
+        }
+        else {
+            stringToLineResult.lines.push(stringToLineResult.partial);
+            stringToLineResult.partial = "";
+        }
+        if (stringToLineResult.lines.length > 0) {
+            var prom = void 0;
+            if (runtime.preFileLineHook) {
+                prom = this.runPreLineHook(stringToLineResult.lines);
+            }
+            else {
+                prom = bluebird_1.default.resolve(stringToLineResult.lines);
+            }
+            return prom.then(function (lines) {
+                if (!runtime.started
+                    && !_this.runtime.headers) {
+                    return _this.processDataWithHead(lines);
+                }
+                else {
+                    return _this.processCSVBody(lines);
+                }
+            });
+        }
+        else {
+            return bluebird_1.default.resolve([]);
+        }
+    };
+    ProcessorLocal.prototype.processDataWithHead = function (lines) {
+        if (this.params.noheader) {
+            if (this.params.headers) {
+                this.runtime.headers = this.params.headers;
+            }
+            else {
+                this.runtime.headers = [];
+            }
+        }
+        else {
+            var left = "";
+            var headerRow = [];
+            while (lines.length) {
+                var line = left + lines.shift();
+                var row = this.rowSplit.parse(line);
+                if (row.closed) {
+                    headerRow = row.cells;
+                    left = "";
+                    break;
+                }
+                else {
+                    left = line + getEol_1.default(line, this.runtime);
+                }
+            }
+            this.prependLeftBuf(util_1.bufFromString(left));
+            if (headerRow.length === 0) {
+                return [];
+            }
+            if (this.params.headers) {
+                this.runtime.headers = this.params.headers;
+            }
+            else {
+                this.runtime.headers = headerRow;
+            }
+        }
+        if (this.runtime.needProcessIgnoreColumn || this.runtime.needProcessIncludeColumn) {
+            this.filterHeader();
+        }
+        if (this.needEmitHead && !this.headEmitted) {
+            this.converter.emit("header", this.runtime.headers);
+            this.headEmitted = true;
+        }
+        return this.processCSVBody(lines);
+    };
+    ProcessorLocal.prototype.filterHeader = function () {
+        this.runtime.selectedColumns = [];
+        if (this.runtime.headers) {
+            var headers = this.runtime.headers;
+            for (var i = 0; i < headers.length; i++) {
+                if (this.params.ignoreColumns) {
+                    if (this.params.ignoreColumns.test(headers[i])) {
+                        if (this.params.includeColumns && this.params.includeColumns.test(headers[i])) {
+                            this.runtime.selectedColumns.push(i);
+                        }
+                        else {
+                            continue;
+                        }
+                    }
+                    else {
+                        this.runtime.selectedColumns.push(i);
+                    }
+                }
+                else if (this.params.includeColumns) {
+                    if (this.params.includeColumns.test(headers[i])) {
+                        this.runtime.selectedColumns.push(i);
+                    }
+                }
+                else {
+                    this.runtime.selectedColumns.push(i);
+                }
+                // if (this.params.includeColumns && this.params.includeColumns.test(headers[i])){
+                //   this.runtime.selectedColumns.push(i);
+                // }else{
+                //   if (this.params.ignoreColumns && this.params.ignoreColumns.test(headers[i])){
+                //     continue;
+                //   }else{
+                //     if (this.params.ignoreColumns && !this.params.includeColumns){
+                //       this.runtime.selectedColumns.push(i);
+                //     }
+                //   }
+                // }
+            }
+            this.runtime.headers = util_1.filterArray(this.runtime.headers, this.runtime.selectedColumns);
+        }
+    };
+    ProcessorLocal.prototype.processCSVBody = function (lines) {
+        if (this.params.output === "line") {
+            return lines;
+        }
+        else {
+            var result = this.rowSplit.parseMultiLines(lines);
+            this.prependLeftBuf(util_1.bufFromString(result.partial));
+            if (this.params.output === "csv") {
+                return result.rowsCells;
+            }
+            else {
+                return lineToJson_1.default(result.rowsCells, this.converter);
+            }
+        }
+        // var jsonArr = linesToJson(lines.lines, params, this.recordNum);
+        // this.processResult(jsonArr);
+        // this.lastIndex += jsonArr.length;
+        // this.recordNum += jsonArr.length;
+    };
+    ProcessorLocal.prototype.prependLeftBuf = function (buf) {
+        if (buf) {
+            if (this.runtime.csvLineBuffer) {
+                this.runtime.csvLineBuffer = Buffer.concat([buf, this.runtime.csvLineBuffer]);
+            }
+            else {
+                this.runtime.csvLineBuffer = buf;
+            }
+        }
+    };
+    ProcessorLocal.prototype.runPreLineHook = function (lines) {
+        var _this = this;
+        return new bluebird_1.default(function (resolve, reject) {
+            processLineHook(lines, _this.runtime, 0, function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(lines);
+                }
+            });
+        });
+    };
+    return ProcessorLocal;
+}(Processor_1.Processor));
+exports.ProcessorLocal = ProcessorLocal;
+function processLineHook(lines, runtime, offset, cb) {
+    if (offset >= lines.length) {
+        cb();
+    }
+    else {
+        if (runtime.preFileLineHook) {
+            var line = lines[offset];
+            var res = runtime.preFileLineHook(line, runtime.parsedLineNumber + offset);
+            offset++;
+            if (res && res.then) {
+                res.then(function (value) {
+                    lines[offset - 1] = value;
+                    processLineHook(lines, runtime, offset, cb);
+                });
+            }
+            else {
+                lines[offset - 1] = res;
+                while (offset < lines.length) {
+                    lines[offset] = runtime.preFileLineHook(lines[offset], runtime.parsedLineNumber + offset);
+                    offset++;
+                }
+                cb();
+            }
+        }
+        else {
+            cb();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/ProcessorLocal.ts","sources":["/Users/kxiang/work/projects/csv2json/src/ProcessorLocal.ts"],"names":[],"mappings":"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","sourcesContent":["import { Processor, ProcessLineResult } from \"./Processor\";\nimport P from \"bluebird\";\nimport { prepareData } from \"./dataClean\";\nimport getEol from \"./getEol\";\nimport { stringToLines } from \"./fileline\";\nimport { bufFromString, filterArray,trimLeft } from \"./util\";\nimport { RowSplit } from \"./rowSplit\";\nimport lineToJson from \"./lineToJson\";\nimport { ParseRuntime } from \"./ParseRuntime\";\nimport CSVError from \"./CSVError\";\n\n\n\nexport class ProcessorLocal extends Processor {\n  flush(): P<ProcessLineResult[]> {\n    if (this.runtime.csvLineBuffer && this.runtime.csvLineBuffer.length > 0) {\n      const buf = this.runtime.csvLineBuffer;\n      this.runtime.csvLineBuffer = undefined;\n      return this.process(buf, true)\n        .then((res) => {\n          if (this.runtime.csvLineBuffer && this.runtime.csvLineBuffer.length > 0) {\n            return P.reject(CSVError.unclosed_quote(this.runtime.parsedLineNumber, this.runtime.csvLineBuffer.toString()))\n          } else {\n            return P.resolve(res);\n          }\n        })\n    } else {\n      return P.resolve([]);\n    }\n  }\n  destroy(): P<void> {\n    return P.resolve();\n  }\n  private rowSplit: RowSplit = new RowSplit(this.converter);\n  private eolEmitted = false;\n  private _needEmitEol?: boolean = undefined;\n  private get needEmitEol() {\n    if (this._needEmitEol === undefined) {\n      this._needEmitEol = this.converter.listeners(\"eol\").length > 0;\n    }\n    return this._needEmitEol;\n  }\n  private headEmitted = false;\n  private _needEmitHead?: boolean = undefined;\n  private get needEmitHead() {\n    if (this._needEmitHead === undefined) {\n      this._needEmitHead = this.converter.listeners(\"header\").length > 0;\n    }\n    return this._needEmitHead;\n\n  }\n  process(chunk: Buffer, finalChunk = false): P<ProcessLineResult[]> {\n    let csvString: string;\n    if (finalChunk) {\n      csvString = chunk.toString();\n    } else {\n      csvString = prepareData(chunk, this.converter.parseRuntime);\n\n    }\n    return P.resolve()\n      .then(() => {\n        if (this.runtime.preRawDataHook) {\n          return this.runtime.preRawDataHook(csvString);\n        } else {\n          return csvString;\n        }\n      })\n      .then((csv) => {\n        if (csv && csv.length > 0) {\n          return this.processCSV(csv, finalChunk);\n        } else {\n          return P.resolve([]);\n        }\n      })\n  }\n  private processCSV(csv: string, finalChunk: boolean): P<ProcessLineResult[]> {\n    const params = this.params;\n    const runtime = this.runtime;\n    if (!runtime.eol) {\n      getEol(csv, runtime);\n    }\n    if (this.needEmitEol && !this.eolEmitted && runtime.eol) {\n      this.converter.emit(\"eol\", runtime.eol);\n      this.eolEmitted = true;\n    }\n    // trim csv file has initial blank lines.\n    if (params.ignoreEmpty && !runtime.started) {\n      csv = trimLeft(csv);\n    }\n    const stringToLineResult = stringToLines(csv, runtime);\n    if (!finalChunk) {\n      this.prependLeftBuf(bufFromString(stringToLineResult.partial));\n    } else {\n      stringToLineResult.lines.push(stringToLineResult.partial);\n      stringToLineResult.partial = \"\";\n    }\n    if (stringToLineResult.lines.length > 0) {\n      let prom: P<string[]>;\n      if (runtime.preFileLineHook) {\n        prom = this.runPreLineHook(stringToLineResult.lines);\n      } else {\n        prom = P.resolve(stringToLineResult.lines);\n      }\n      return prom.then((lines) => {\n        if (!runtime.started\n          && !this.runtime.headers\n        ) {\n          return this.processDataWithHead(lines);\n        } else {\n          return this.processCSVBody(lines);\n        }\n\n      })\n\n    } else {\n\n      return P.resolve([]);\n    }\n\n  }\n  private processDataWithHead(lines: string[]): ProcessLineResult[] {\n    if (this.params.noheader) {\n      if (this.params.headers) {\n        this.runtime.headers = this.params.headers;\n      } else {\n        this.runtime.headers = [];\n      }\n    } else {\n      let left = \"\";\n      let headerRow: string[] = [];\n      while (lines.length) {\n        const line = left + lines.shift();\n        const row = this.rowSplit.parse(line);\n        if (row.closed) {\n          headerRow = row.cells;\n          left = \"\";\n          break;\n        } else {\n          left = line + getEol(line, this.runtime);\n        }\n      }\n      this.prependLeftBuf(bufFromString(left));\n\n      if (headerRow.length === 0) {\n        return [];\n      }\n      if (this.params.headers) {\n        this.runtime.headers = this.params.headers;\n      } else {\n        this.runtime.headers = headerRow;\n      }\n    }\n    if (this.runtime.needProcessIgnoreColumn || this.runtime.needProcessIncludeColumn) {\n      this.filterHeader();\n    }\n    if (this.needEmitHead && !this.headEmitted) {\n      this.converter.emit(\"header\", this.runtime.headers);\n      this.headEmitted = true;\n    }\n    return this.processCSVBody(lines);\n  }\n  private filterHeader() {\n    this.runtime.selectedColumns = [];\n    if (this.runtime.headers) {\n      const headers = this.runtime.headers;\n      for (let i = 0; i < headers.length; i++) {\n        if (this.params.ignoreColumns) {\n          if (this.params.ignoreColumns.test(headers[i])) {\n            if (this.params.includeColumns && this.params.includeColumns.test(headers[i])) {\n              this.runtime.selectedColumns.push(i);\n            } else {\n              continue;\n            }\n          } else {\n            this.runtime.selectedColumns.push(i);\n          }\n        } else if (this.params.includeColumns) {\n          if (this.params.includeColumns.test(headers[i])) {\n            this.runtime.selectedColumns.push(i);\n          }\n        } else {\n          this.runtime.selectedColumns.push(i);\n        }\n        // if (this.params.includeColumns && this.params.includeColumns.test(headers[i])){\n        //   this.runtime.selectedColumns.push(i);\n        // }else{\n        //   if (this.params.ignoreColumns && this.params.ignoreColumns.test(headers[i])){\n        //     continue;\n        //   }else{\n        //     if (this.params.ignoreColumns && !this.params.includeColumns){\n        //       this.runtime.selectedColumns.push(i);\n        //     }\n\n        //   }\n        // }\n      }\n      this.runtime.headers = filterArray(this.runtime.headers, this.runtime.selectedColumns);\n    }\n\n  }\n  private processCSVBody(lines: string[]): ProcessLineResult[] {\n    if (this.params.output === \"line\") {\n      return lines;\n    } else {\n      const result = this.rowSplit.parseMultiLines(lines);\n      this.prependLeftBuf(bufFromString(result.partial));\n      if (this.params.output === \"csv\") {\n        return result.rowsCells;\n      } else {\n        return lineToJson(result.rowsCells, this.converter);\n      }\n    }\n\n    // var jsonArr = linesToJson(lines.lines, params, this.recordNum);\n    // this.processResult(jsonArr);\n    // this.lastIndex += jsonArr.length;\n    // this.recordNum += jsonArr.length;\n  }\n\n  private prependLeftBuf(buf: Buffer) {\n    if (buf) {\n      if (this.runtime.csvLineBuffer) {\n        this.runtime.csvLineBuffer = Buffer.concat([buf, this.runtime.csvLineBuffer]);\n      } else {\n        this.runtime.csvLineBuffer = buf;\n      }\n    }\n\n  }\n  private runPreLineHook(lines: string[]): P<string[]> {\n    return new P((resolve, reject) => {\n      processLineHook(lines, this.runtime, 0, (err) => {\n        if (err) {\n          reject(err);\n        } else {\n          resolve(lines);\n        }\n      })\n    });\n  }\n}\n\nfunction processLineHook(lines: string[], runtime: ParseRuntime, offset: number,\n  cb: (err?) => void\n) {\n  if (offset >= lines.length) {\n    cb();\n  } else {\n    if (runtime.preFileLineHook) {\n      const line = lines[offset];\n      const res = runtime.preFileLineHook(line, runtime.parsedLineNumber + offset);\n      offset++;\n      if (res && (res as PromiseLike<string>).then) {\n        (res as PromiseLike<string>).then((value) => {\n          lines[offset - 1] = value;\n          processLineHook(lines, runtime, offset, cb);\n        });\n      } else {\n        lines[offset - 1] = res as string;\n        while (offset < lines.length) {\n          lines[offset] = runtime.preFileLineHook(lines[offset], runtime.parsedLineNumber + offset) as string;\n          offset++;\n        }\n        cb();\n      }\n    } else {\n      cb();\n    }\n  }\n}"]}

.ts-node/4c960549d...34f7c2da2287e3d58928ceb5b83feb3b528b.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function mergeParams(params) {
+    var defaultParam = {
+        delimiter: ',',
+        ignoreColumns: undefined,
+        includeColumns: undefined,
+        quote: '"',
+        trim: true,
+        checkType: false,
+        ignoreEmpty: false,
+        // fork: false,
+        noheader: false,
+        headers: undefined,
+        flatKeys: false,
+        maxRowLength: 0,
+        checkColumn: false,
+        escape: '"',
+        colParser: {},
+        eol: undefined,
+        alwaysSplitAtEOL: false,
+        output: "json",
+        nullObject: false,
+        downstreamFormat: "line",
+        needEmitAll: true
+    };
+    if (!params) {
+        params = {};
+    }
+    for (var key in params) {
+        if (params.hasOwnProperty(key)) {
+            if (Array.isArray(params[key])) {
+                defaultParam[key] = [].concat(params[key]);
+            }
+            else {
+                defaultParam[key] = params[key];
+            }
+        }
+    }
+    return defaultParam;
+}
+exports.mergeParams = mergeParams;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/Parameters.ts","sources":["/Users/kxiang/work/projects/csv2json/src/Parameters.ts"],"names":[],"mappings":";;AAiGA,qBAA4B,MAA+B;IACzD,IAAM,YAAY,GAAkB;QAClC,SAAS,EAAE,GAAG;QACd,aAAa,EAAE,SAAS;QACxB,cAAc,EAAE,SAAS;QACzB,KAAK,EAAE,GAAG;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,KAAK;QAChB,WAAW,EAAE,KAAK;QAClB,eAAe;QACf,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,SAAS;QAClB,QAAQ,EAAE,KAAK;QACf,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,KAAK;QAClB,MAAM,EAAE,GAAG;QACX,SAAS,EAAE,EAAE;QACb,GAAG,EAAE,SAAS;QACd,gBAAgB,EAAE,KAAK;QACvB,MAAM,EAAE,MAAM;QACd,UAAU,EAAE,KAAK;QACjB,gBAAgB,EAAC,MAAM;QACvB,WAAW,EAAC,IAAI;KACjB,CAAA;IACD,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,GAAG,EAAE,CAAC;KACb;IACD,KAAK,IAAI,GAAG,IAAI,MAAM,EAAE;QACtB,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;YAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;gBAC9B,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aAC5C;iBAAM;gBACL,YAAY,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;aACjC;SACF;KACF;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AArCD,kCAqCC","sourcesContent":["export interface CSVParseParam {\n  /**\n   *   delimiter used for seperating columns. Use \"auto\" if delimiter is unknown in advance, in this case, delimiter will be auto-detected (by best attempt). Use an array to give a list of potential delimiters e.g. [\",\",\"|\",\"$\"]. default: \",\"\n   */\n  delimiter: string | string[];\n  /**\n   *  This parameter instructs the parser to ignore columns as specified by the regular expression. Example: /(name|age)/ will ignore columns whose header contains \"name\" or \"age\"\n   */\n  ignoreColumns?: RegExp;\n  /**\n   *  This parameter instructs the parser to include only those columns as specified by the regular expression. Example: /(name|age)/ will parse and include columns whose header contains \"name\" or \"age\"\n   */\n  includeColumns?: RegExp;\n  /**\n   *  If a column contains delimiter, it is able to use quote character to surround the column content. e.g. \"hello, world\" wont be split into two columns while parsing. Set to \"off\" will ignore all quotes. default: \" (double quote)\n   */\n  quote: string;\n  /**\n   *  Indicate if parser trim off spaces surrounding column content. e.g. \" content \" will be trimmed to \"content\". Default: true\n   */\n  trim: boolean;\n  /**\n   *  This parameter turns on and off whether check field type. Default is false. \n   */\n  checkType: boolean;\n  /**\n   *  Ignore the empty value in CSV columns. If a column value is not given, set this to true to skip them. Default: false.\n   */\n  ignoreEmpty: boolean;\n  /**\n   *  Delegate parsing work to another process.\n   */\n  // fork: boolean;\n  /**\n   *  Indicating csv data has no header row and first row is data row. Default is false.\n   */\n  noheader: boolean;\n  /**\n   *  An array to specify the headers of CSV data. If --noheader is false, this value will override CSV header row. Default: null. Example: [\"my field\",\"name\"].\n   */\n  headers?: string[];\n  /**\n   *  Don't interpret dots (.) and square brackets in header fields as nested object or array identifiers at all (treat them like regular characters for JSON field identifiers). Default: false.\n   */\n  flatKeys: boolean;\n  /**\n   *  the max character a csv row could have. 0 means infinite. If max number exceeded, parser will emit \"error\" of \"row_exceed\". if a possibly corrupted csv data provided, give it a number like 65535 so the parser wont consume memory. default: 0\n   */\n  maxRowLength: number;\n  /**\n   *  whether check column number of a row is the same as headers. If column number mismatched headers number, an error of \"mismatched_column\" will be emitted.. default: false\n   */\n  checkColumn: boolean;\n  /**\n   *  escape character used in quoted column. Default is double quote (\") according to RFC4108. Change to back slash (\\) or other chars for your own case.\n   */\n  escape: string;\n  /**\n   *   Allows override parsing logic for a specific column. It accepts a JSON object with fields like: headName: <String | Function> . e.g. {field1:'number'} will use built-in number parser to convert value of the field1 column to number. Another example {\"name\":nameProcessFunc} will use specified function to parse the value.\n   */\n  colParser: {\n    [key: string]: string | CellParser | ColumnParam\n  };\n  /**\n   *  End of line character. If omitted, parser will attempt to retrieve it from the first chunks of CSV data\n   */\n  eol?: string;\n  /**\n   *  Always interpret each line (as defined by eol) as a row. This will prevent eol characters from being used within a row (even inside a quoted field). Default is false. Change to true if you are confident no inline line breaks (like line break in a cell which has multi line text)\n   */\n  alwaysSplitAtEOL: boolean;\n  /**\n   * The format to be converted to. \"json\" (default) -- convert csv to json. \"csv\" -- convert csv to csv row array. \"line\" -- convert csv to csv line string \n   */\n  output: \"json\" | \"csv\" | \"line\";\n\n  /**\n   * Convert string \"null\" to null object in JSON outputs. Default is false.\n   */\n  nullObject:boolean;\n  /**\n   * Define the format required by downstream (this parameter does not work if objectMode is on). `line` -- json is emitted in a single line separated by a line breake like \"json1\\njson2\" . `array` -- downstream requires array format like \"[json1,json2]\". Default is line.\n   */\n  downstreamFormat: \"line\" | \"array\";\n  /**\n   * Define whether .then(callback) returns all JSON data in its callback. Default is true. Change to false to save memory if subscribing json lines.\n   */\n  needEmitAll: boolean;\n}\n\nexport type CellParser = (item: string, head: string, resultRow: any, row: string[], columnIndex: number) => any;\n\nexport interface ColumnParam {\n  flat?: boolean;\n  cellParser?: string | CellParser;\n}\n\nexport function mergeParams(params?: Partial<CSVParseParam>): CSVParseParam {\n  const defaultParam: CSVParseParam = {\n    delimiter: ',',\n    ignoreColumns: undefined,\n    includeColumns: undefined,\n    quote: '\"',\n    trim: true,\n    checkType: false,\n    ignoreEmpty: false,\n    // fork: false,\n    noheader: false,\n    headers: undefined,\n    flatKeys: false,\n    maxRowLength: 0,\n    checkColumn: false,\n    escape: '\"',\n    colParser: {},\n    eol: undefined,\n    alwaysSplitAtEOL: false,\n    output: \"json\",\n    nullObject: false,\n    downstreamFormat:\"line\",\n    needEmitAll:true\n  }\n  if (!params) {\n    params = {};\n  }\n  for (let key in params) {\n    if (params.hasOwnProperty(key)) {\n      if (Array.isArray(params[key])) {\n        defaultParam[key] = [].concat(params[key]);\n      } else {\n        defaultParam[key] = params[key];\n      }\n    }\n  }\n  return defaultParam;\n}\n\n"]}

.ts-node/4c960549d...cb6f79647e7f5e59dce04654581288e7e3e7.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Processor = /** @class */ (function () {
+    function Processor(converter) {
+        this.converter = converter;
+        this.params = converter.parseParam;
+        this.runtime = converter.parseRuntime;
+    }
+    return Processor;
+}());
+exports.Processor = Processor;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9Qcm9jZXNzb3IudHMiLCJzb3VyY2VzIjpbIi9Vc2Vycy9reGlhbmcvd29yay9wcm9qZWN0cy9jc3YyanNvbi9zcmMvUHJvY2Vzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBTUE7SUFHRSxtQkFBc0IsU0FBb0I7UUFBcEIsY0FBUyxHQUFULFNBQVMsQ0FBVztRQUN4QyxJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxVQUFVLENBQUM7UUFDbkMsSUFBSSxDQUFDLE9BQU8sR0FBRyxTQUFTLENBQUMsWUFBWSxDQUFDO0lBQ3hDLENBQUM7SUFJSCxnQkFBQztBQUFELENBQUMsQUFWRCxJQVVDO0FBVnFCLDhCQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udmVydGVyIH0gZnJvbSBcIi4vQ29udmVydGVyXCI7XG5pbXBvcnQgUCBmcm9tIFwiYmx1ZWJpcmRcIjtcbmltcG9ydCB7IEpTT05SZXN1bHQgfSBmcm9tIFwiLi9saW5lVG9Kc29uXCI7XG5pbXBvcnQgeyBDU1ZQYXJzZVBhcmFtIH0gZnJvbSBcIi4vUGFyYW1ldGVyc1wiO1xuaW1wb3J0IHsgUGFyc2VSdW50aW1lIH0gZnJvbSBcIi4vUGFyc2VSdW50aW1lXCI7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBQcm9jZXNzb3Ige1xuICBwcm90ZWN0ZWQgcGFyYW1zOiBDU1ZQYXJzZVBhcmFtO1xuICBwcm90ZWN0ZWQgcnVudGltZTogUGFyc2VSdW50aW1lO1xuICBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgY29udmVydGVyOiBDb252ZXJ0ZXIpIHtcbiAgICB0aGlzLnBhcmFtcyA9IGNvbnZlcnRlci5wYXJzZVBhcmFtO1xuICAgIHRoaXMucnVudGltZSA9IGNvbnZlcnRlci5wYXJzZVJ1bnRpbWU7XG4gIH1cbiAgYWJzdHJhY3QgcHJvY2VzcyhjaHVuazogQnVmZmVyLGZpbmFsQ2h1bms/OmJvb2xlYW4pOiBQPFByb2Nlc3NMaW5lUmVzdWx0W10+XG4gIGFic3RyYWN0IGRlc3Ryb3koKTpQPHZvaWQ+O1xuICBhYnN0cmFjdCBmbHVzaCgpOiBQPFByb2Nlc3NMaW5lUmVzdWx0W10+O1xufVxuZXhwb3J0IHR5cGUgUHJvY2Vzc0xpbmVSZXN1bHQgPSBzdHJpbmcgfCBzdHJpbmdbXSB8IEpTT05SZXN1bHQ7XG4iXX0=

.ts-node/4c960549d...3baabb47d90efcb26810c79a570fed5ad880.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//return first eol found from a data chunk.
+function default_1(data, param) {
+    if (!param.eol && data) {
+        for (var i = 0, len = data.length; i < len; i++) {
+            if (data[i] === "\r") {
+                if (data[i + 1] === "\n") {
+                    param.eol = "\r\n";
+                    break;
+                }
+                else if (data[i + 1]) {
+                    param.eol = "\r";
+                    break;
+                }
+            }
+            else if (data[i] === "\n") {
+                param.eol = "\n";
+                break;
+            }
+        }
+    }
+    return param.eol || "\n";
+}
+exports.default = default_1;
+;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9nZXRFb2wudHMiLCJzb3VyY2VzIjpbIi9Vc2Vycy9reGlhbmcvd29yay9wcm9qZWN0cy9jc3YyanNvbi9zcmMvZ2V0RW9sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQ0EsMkNBQTJDO0FBQzNDLG1CQUF5QixJQUFZLEVBQUUsS0FBbUI7SUFDeEQsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLElBQUksSUFBSSxFQUFFO1FBQ3RCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEdBQUcsR0FBRyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsR0FBRyxHQUFHLEVBQUUsQ0FBQyxFQUFFLEVBQUU7WUFDL0MsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssSUFBSSxFQUFFO2dCQUNwQixJQUFJLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssSUFBSSxFQUFFO29CQUN4QixLQUFLLENBQUMsR0FBRyxHQUFHLE1BQU0sQ0FBQztvQkFDbkIsTUFBTTtpQkFDUDtxQkFBTSxJQUFJLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUU7b0JBQ3RCLEtBQUssQ0FBQyxHQUFHLEdBQUcsSUFBSSxDQUFDO29CQUNqQixNQUFNO2lCQUNQO2FBQ0Y7aUJBQU0sSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssSUFBSSxFQUFFO2dCQUMzQixLQUFLLENBQUMsR0FBRyxHQUFHLElBQUksQ0FBQztnQkFDakIsTUFBTTthQUNQO1NBQ0Y7S0FDRjtJQUNELE9BQU8sS0FBSyxDQUFDLEdBQUcsSUFBSSxJQUFJLENBQUM7QUFDM0IsQ0FBQztBQWxCRCw0QkFrQkM7QUFBQSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGFyc2VSdW50aW1lIH0gZnJvbSBcIi4vUGFyc2VSdW50aW1lXCI7XG4vL3JldHVybiBmaXJzdCBlb2wgZm91bmQgZnJvbSBhIGRhdGEgY2h1bmsuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiAoZGF0YTogc3RyaW5nLCBwYXJhbTogUGFyc2VSdW50aW1lKTogc3RyaW5nIHtcbiAgaWYgKCFwYXJhbS5lb2wgJiYgZGF0YSkge1xuICAgIGZvciAodmFyIGkgPSAwLCBsZW4gPSBkYXRhLmxlbmd0aDsgaSA8IGxlbjsgaSsrKSB7XG4gICAgICBpZiAoZGF0YVtpXSA9PT0gXCJcXHJcIikge1xuICAgICAgICBpZiAoZGF0YVtpICsgMV0gPT09IFwiXFxuXCIpIHtcbiAgICAgICAgICBwYXJhbS5lb2wgPSBcIlxcclxcblwiO1xuICAgICAgICAgIGJyZWFrO1xuICAgICAgICB9IGVsc2UgaWYgKGRhdGFbaSArIDFdKSB7XG4gICAgICAgICAgcGFyYW0uZW9sID0gXCJcXHJcIjtcbiAgICAgICAgICBicmVhaztcbiAgICAgICAgfSBcbiAgICAgIH0gZWxzZSBpZiAoZGF0YVtpXSA9PT0gXCJcXG5cIikge1xuICAgICAgICBwYXJhbS5lb2wgPSBcIlxcblwiO1xuICAgICAgICBicmVhaztcbiAgICAgIH1cbiAgICB9XG4gIH1cbiAgcmV0dXJuIHBhcmFtLmVvbCB8fCBcIlxcblwiO1xufTtcbiJdfQ==

.ts-node/4c960549d...531410ecb53ccdbe486e410336329db2fdb4.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var rowSplit_1 = require("./rowSplit");
+var Converter_1 = require("./Converter");
+var assert = require("assert");
+describe("Test delimiters", function () {
+    var getDelimiter = function (str, opt) {
+        return rowSplit_1.RowSplit.prototype["getDelimiter"].call({
+            conv: {
+                parseParam: {
+                    delimiter: opt.delimiter
+                }
+            }
+        }, str);
+    };
+    it("should return the explicitly specified delimiter", function () {
+        var delimiter = ";";
+        var rowStr = "a;b;c";
+        var returnedDelimiter = getDelimiter(rowStr, { delimiter: ";" });
+        assert.equal(returnedDelimiter, delimiter);
+    });
+    it("should return the autodetected delimiter if 'auto' specified", function () {
+        var rowStr = "a;b;c";
+        var returnedDelimiter = getDelimiter(rowStr, { delimiter: "auto" });
+        assert(returnedDelimiter === ";");
+    });
+    it("should return the ',' delimiter if delimiter cannot be specified, in case of 'auto'", function () {
+        var rowStr = "abc";
+        var returnedDelimiter = getDelimiter(rowStr, { delimiter: "auto" });
+        assert(returnedDelimiter === ",");
+    });
+    it("should accetp an array with potential delimiters", function () {
+        var rowStr = "a$b$c";
+        var returnedDelimiter = getDelimiter(rowStr, { delimiter: [",", ";", "$"] });
+        assert(returnedDelimiter === '$');
+    });
+});
+describe("ParseMultiLine function", function () {
+    var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter());
+    var func = function (lines) {
+        return rowSplit.parseMultiLines(lines);
+    };
+    it("should convert lines to csv lines", function () {
+        var lines = [
+            "a,b,c,d",
+            "hello,world,csvtojson,abc",
+            "1,2,3,4"
+        ];
+        var res = func(lines);
+        assert.equal(res.rowsCells.length, 3);
+        assert.equal(res.partial, "");
+    });
+    it("should process line breaks", function () {
+        var lines = [
+            "a,b,c",
+            '15",hello,"ab',
+            "cde\"",
+            "\"b\"\"b\",cc,dd"
+        ];
+        var res = func(lines);
+        assert.equal(res.rowsCells.length, 3);
+        assert.equal(res.rowsCells[1][0], "15\"");
+        assert.equal(res.rowsCells[1][2], "ab\ncde");
+        assert.equal(res.rowsCells[2][0], "b\"b");
+        assert.equal(res.partial, "");
+    });
+    it("should return partial if line not closed", function () {
+        var lines = [
+            "a,b,c",
+            '15",hello,"ab',
+            "d,e,f"
+        ];
+        var res = func(lines);
+        assert.equal(res.rowsCells.length, 1);
+        assert.equal(res.partial, "15\",hello,\"ab\nd,e,f\n");
+    });
+});
+describe("RowSplit.parse function", function () {
+    var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter());
+    var func = function (str) {
+        return rowSplit.parse(str);
+    };
+    it("should split complete csv line", function () {
+        var str = "hello,world,csvtojson,awesome";
+        var res = func(str);
+        assert.equal(res.cells.length, 4);
+        assert.equal(res.closed, true);
+    });
+    it("should split incomplete csv line", function () {
+        var str = "hello,world,\"csvtojson,awesome";
+        var res = func(str);
+        assert.equal(res.closed, false);
+    });
+    it("should allow multiple line", function () {
+        var str = "\"he\"llo\",world,\"csvtojson,a\"\nwesome\"";
+        var res = func(str);
+        assert.equal(res.closed, true);
+        assert.equal(res.cells[2], 'csvtojson,a"\nwesome');
+    });
+    it("should allow blank quotes", function () {
+        var data = "a|^^|^b^";
+        var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter({
+            delimiter: '|',
+            quote: '^',
+            noheader: true
+        }));
+        var res = rowSplit.parse(data);
+        assert.equal(res.cells[1], "");
+    });
+    it("should allow blank quotes in quotes", function () {
+        var data = 'a,"hello,this,"", test"';
+        var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter({
+            noheader: true
+        }));
+        var res = rowSplit.parse(data);
+        assert.equal(res.cells[1], 'hello,this,", test');
+    });
+    it("should smart detect if an initial quote is only part of value ", function () {
+        var data = '"Weight" (kg),Error code,"Height" (m)';
+        var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter({
+            noheader: true
+        }));
+        var res = rowSplit.parse(data);
+        assert.equal(res.cells.length, 3);
+        assert(res.closed);
+        assert.equal(res.cells[0], '"Weight" (kg)');
+        assert.equal(res.cells[1], 'Error code');
+        assert.equal(res.cells[2], '"Height" (m)');
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/rowSplit.test.ts","sources":["/Users/kxiang/work/projects/csv2json/src/rowSplit.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { RowSplit, MultipleRowResult, RowSplitResult } from \"./rowSplit\";\nimport { Converter } from \"./Converter\";\nconst assert = require(\"assert\");\n\ndescribe(\"Test delimiters\", function () {\n  const getDelimiter = (str, opt: { delimiter: string | string[] }): string => {\n    return RowSplit.prototype[\"getDelimiter\"].call({\n      conv: {\n        parseParam: {\n          delimiter: opt.delimiter\n        }\n      }\n    }, str);\n  }\n\n  it(\"should return the explicitly specified delimiter\", function () {\n    var delimiter = \";\";\n    var rowStr = \"a;b;c\";\n    var returnedDelimiter = getDelimiter(rowStr, { delimiter: \";\" });\n    assert.equal(returnedDelimiter, delimiter);\n  });\n\n  it(\"should return the autodetected delimiter if 'auto' specified\", function () {\n    var rowStr = \"a;b;c\";\n    var returnedDelimiter = getDelimiter(rowStr, { delimiter: \"auto\" });\n    assert(returnedDelimiter === \";\");\n  });\n\n  it(\"should return the ',' delimiter if delimiter cannot be specified, in case of 'auto'\", function () {\n    var rowStr = \"abc\";\n    var returnedDelimiter = getDelimiter(rowStr, { delimiter: \"auto\" });\n    assert(returnedDelimiter === \",\");\n  });\n\n  it(\"should accetp an array with potential delimiters\", function () {\n    var rowStr = \"a$b$c\";\n    var returnedDelimiter = getDelimiter(rowStr, { delimiter: [\",\", \";\", \"$\"] });\n    assert(returnedDelimiter === '$');\n  });\n});\n\ndescribe(\"ParseMultiLine function\", function () {\n  const rowSplit = new RowSplit(new Converter());\n  const func = (lines: string[]): MultipleRowResult => {\n    return rowSplit.parseMultiLines(lines);\n  }\n  it(\"should convert lines to csv lines\", function () {\n    var lines = [\n      \"a,b,c,d\",\n      \"hello,world,csvtojson,abc\",\n      \"1,2,3,4\"\n    ];\n    var res = func(lines);\n    assert.equal(res.rowsCells.length, 3);\n    assert.equal(res.partial, \"\");\n  });\n\n  it(\"should process line breaks\", function () {\n    var lines = [\n      \"a,b,c\",\n      '15\",hello,\"ab',\n      \"cde\\\"\",\n      \"\\\"b\\\"\\\"b\\\",cc,dd\"\n    ];\n    var res = func(lines);\n    assert.equal(res.rowsCells.length, 3);\n    assert.equal(res.rowsCells[1][0], \"15\\\"\");\n    assert.equal(res.rowsCells[1][2], \"ab\\ncde\");\n    assert.equal(res.rowsCells[2][0], \"b\\\"b\");\n    assert.equal(res.partial, \"\");\n  });\n\n  it(\"should return partial if line not closed\", function () {\n    var lines = [\n      \"a,b,c\",\n      '15\",hello,\"ab',\n      \"d,e,f\"\n    ];\n    var res = func(lines);\n    assert.equal(res.rowsCells.length, 1);\n    assert.equal(res.partial, \"15\\\",hello,\\\"ab\\nd,e,f\\n\");\n  });\n});\n\ndescribe(\"RowSplit.parse function\", function () {\n  const rowSplit = new RowSplit(new Converter());\n  const func = (str): RowSplitResult => {\n    return rowSplit.parse(str);\n  }\n  it(\"should split complete csv line\", function () {\n    var str = \"hello,world,csvtojson,awesome\";\n    var res = func(str);\n    assert.equal(res.cells.length, 4);\n    assert.equal(res.closed, true);\n  });\n\n  it(\"should split incomplete csv line\", function () {\n    var str = \"hello,world,\\\"csvtojson,awesome\";\n    var res = func(str);\n    assert.equal(res.closed, false);\n  });\n\n  it(\"should allow multiple line\", function () {\n    var str = \"\\\"he\\\"llo\\\",world,\\\"csvtojson,a\\\"\\nwesome\\\"\";\n    var res = func(str);\n    assert.equal(res.closed, true);\n    assert.equal(res.cells[2], 'csvtojson,a\"\\nwesome');\n  });\n  it(\"should allow blank quotes\", () => {\n    const data = \"a|^^|^b^\";\n\n    const rowSplit = new RowSplit(new Converter({\n      delimiter: '|',\n      quote: '^',\n      noheader: true\n    }));\n    const res = rowSplit.parse(data);\n    assert.equal(res.cells[1], \"\");\n  })\n  it(\"should allow blank quotes in quotes\", () => {\n    const data = 'a,\"hello,this,\"\", test\"';\n\n    const rowSplit = new RowSplit(new Converter({\n      noheader: true\n    }));\n    const res = rowSplit.parse(data);\n    assert.equal(res.cells[1], 'hello,this,\", test');\n  })\n  it(\"should smart detect if an initial quote is only part of value \", () => {\n    const data = '\"Weight\" (kg),Error code,\"Height\" (m)';\n    const rowSplit = new RowSplit(new Converter({\n      noheader: true\n    }));\n    const res = rowSplit.parse(data);\n    assert.equal(res.cells.length, 3);\n    assert(res.closed);\n    assert.equal(res.cells[0],'\"Weight\" (kg)');\n    assert.equal(res.cells[1],'Error code');\n    assert.equal(res.cells[2],'\"Height\" (m)');\n    \n  })\n});\n"]}

.ts-node/4c960549d...1a1baa361e29c2df52092099a5376d037cb9.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getEol_1 = __importDefault(require("./getEol"));
+// const getEol = require("./getEol");
+/**
+ * convert data chunk to file lines array
+ * @param  {string} data  data chunk as utf8 string
+ * @param  {object} param Converter param object
+ * @return {Object}   {lines:[line1,line2...],partial:String}
+ */
+function stringToLines(data, param) {
+    var eol = getEol_1.default(data, param);
+    var lines = data.split(eol);
+    var partial = lines.pop() || "";
+    return { lines: lines, partial: partial };
+}
+exports.stringToLines = stringToLines;
+;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9maWxlbGluZS50cyIsInNvdXJjZXMiOlsiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9maWxlbGluZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUNBLG9EQUE4QjtBQUM5QixzQ0FBc0M7QUFDdEM7Ozs7O0dBS0c7QUFDSCx1QkFBOEIsSUFBWSxFQUFFLEtBQW1CO0lBQzdELElBQU0sR0FBRyxHQUFHLGdCQUFNLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ2hDLElBQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDOUIsSUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUNsQyxPQUFPLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFDNUMsQ0FBQztBQUxELHNDQUtDO0FBQUEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBhcnNlUnVudGltZSB9IGZyb20gXCIuL1BhcnNlUnVudGltZVwiO1xuaW1wb3J0IGdldEVvbCBmcm9tIFwiLi9nZXRFb2xcIjtcbi8vIGNvbnN0IGdldEVvbCA9IHJlcXVpcmUoXCIuL2dldEVvbFwiKTtcbi8qKlxuICogY29udmVydCBkYXRhIGNodW5rIHRvIGZpbGUgbGluZXMgYXJyYXlcbiAqIEBwYXJhbSAge3N0cmluZ30gZGF0YSAgZGF0YSBjaHVuayBhcyB1dGY4IHN0cmluZ1xuICogQHBhcmFtICB7b2JqZWN0fSBwYXJhbSBDb252ZXJ0ZXIgcGFyYW0gb2JqZWN0XG4gKiBAcmV0dXJuIHtPYmplY3R9ICAge2xpbmVzOltsaW5lMSxsaW5lMi4uLl0scGFydGlhbDpTdHJpbmd9XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzdHJpbmdUb0xpbmVzKGRhdGE6IHN0cmluZywgcGFyYW06IFBhcnNlUnVudGltZSk6IFN0cmluZ1RvTGluZXNSZXN1bHQge1xuICBjb25zdCBlb2wgPSBnZXRFb2woZGF0YSwgcGFyYW0pO1xuICBjb25zdCBsaW5lcyA9IGRhdGEuc3BsaXQoZW9sKTtcbiAgY29uc3QgcGFydGlhbCA9IGxpbmVzLnBvcCgpIHx8IFwiXCI7XG4gIHJldHVybiB7IGxpbmVzOiBsaW5lcywgcGFydGlhbDogcGFydGlhbCB9O1xufTtcblxuXG5leHBvcnQgaW50ZXJmYWNlIFN0cmluZ1RvTGluZXNSZXN1bHQge1xuICBsaW5lczogRmlsZWxpbmVbXSxcbiAgLyoqXG4gICAqIGxhc3QgbGluZSB3aGljaCBjb3VsZCBiZSBpbmNvbXBsZXRlIGxpbmUuXG4gICAqL1xuICBwYXJ0aWFsOiBzdHJpbmdcbn1cbmV4cG9ydCB0eXBlIEZpbGVsaW5lID0gc3RyaW5nOyJdfQ==

.ts-node/4c960549d...c515dd472fccb2f189b66ce7a266fce983f9.js

+"use strict";
+var Converter_1 = require("./Converter");
+var helper = function (param, options) {
+    return new Converter_1.Converter(param, options);
+};
+helper["csv"] = helper;
+helper["Converter"] = Converter_1.Converter;
+module.exports = helper;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9pbmRleC50cyIsInNvdXJjZXMiOlsiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBRUEseUNBQXdDO0FBRXhDLElBQU0sTUFBTSxHQUFHLFVBQVUsS0FBOEIsRUFBRSxPQUEwQjtJQUNqRixPQUFPLElBQUkscUJBQVMsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDdkMsQ0FBQyxDQUFBO0FBQ0QsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLE1BQU0sQ0FBQztBQUN2QixNQUFNLENBQUMsV0FBVyxDQUFDLEdBQUcscUJBQVMsQ0FBQztBQUNoQyxpQkFBUSxNQUFNLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUcmFuc2Zvcm1PcHRpb25zIH0gZnJvbSBcInN0cmVhbVwiO1xuaW1wb3J0IHsgQ1NWUGFyc2VQYXJhbSB9IGZyb20gXCIuL1BhcmFtZXRlcnNcIjtcbmltcG9ydCB7IENvbnZlcnRlciB9IGZyb20gXCIuL0NvbnZlcnRlclwiO1xuXG5jb25zdCBoZWxwZXIgPSBmdW5jdGlvbiAocGFyYW0/OiBQYXJ0aWFsPENTVlBhcnNlUGFyYW0+LCBvcHRpb25zPzogVHJhbnNmb3JtT3B0aW9ucyk6IENvbnZlcnRlciB7XG4gIHJldHVybiBuZXcgQ29udmVydGVyKHBhcmFtLCBvcHRpb25zKTtcbn1cbmhlbHBlcltcImNzdlwiXSA9IGhlbHBlcjtcbmhlbHBlcltcIkNvbnZlcnRlclwiXSA9IENvbnZlcnRlcjtcbmV4cG9ydCA9aGVscGVyO1xuIl19

.ts-node/4c960549d...27e33da138d89fb7c3054fa3b5f0085263e2.js

+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var stream_1 = require("stream");
+var Parameters_1 = require("./Parameters");
+var ParseRuntime_1 = require("./ParseRuntime");
+var bluebird_1 = __importDefault(require("bluebird"));
+// import { ProcessorFork } from "./ProcessFork";
+var ProcessorLocal_1 = require("./ProcessorLocal");
+var Result_1 = require("./Result");
+var Converter = /** @class */ (function (_super) {
+    __extends(Converter, _super);
+    function Converter(param, options) {
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this, options) || this;
+        _this.options = options;
+        _this.params = Parameters_1.mergeParams(param);
+        _this.runtime = ParseRuntime_1.initParseRuntime(_this);
+        _this.result = new Result_1.Result(_this);
+        // if (this.params.fork) {
+        //   this.processor = new ProcessorFork(this);
+        // } else {
+        _this.processor = new ProcessorLocal_1.ProcessorLocal(_this);
+        // }
+        _this.once("error", function (err) {
+            // console.log("BBB");
+            //wait for next cycle to emit the errors.
+            setImmediate(function () {
+                _this.result.processError(err);
+                _this.emit("done", err);
+            });
+        });
+        _this.once("done", function () {
+            _this.processor.destroy();
+        });
+        return _this;
+    }
+    Converter.prototype.preRawData = function (onRawData) {
+        this.runtime.preRawDataHook = onRawData;
+        return this;
+    };
+    Converter.prototype.preFileLine = function (onFileLine) {
+        this.runtime.preFileLineHook = onFileLine;
+        return this;
+    };
+    Converter.prototype.subscribe = function (onNext, onError, onCompleted) {
+        this.parseRuntime.subscribe = {
+            onNext: onNext,
+            onError: onError,
+            onCompleted: onCompleted
+        };
+        return this;
+    };
+    Converter.prototype.fromFile = function (filePath, options) {
+        var _this = this;
+        var fs = require("fs");
+        // var rs = null;
+        // this.wrapCallback(cb, function () {
+        //   if (rs && rs.destroy) {
+        //     rs.destroy();
+        //   }
+        // });
+        fs.exists(filePath, function (exist) {
+            if (exist) {
+                var rs = fs.createReadStream(filePath, options);
+                rs.pipe(_this);
+            }
+            else {
+                _this.emit('error', new Error("File does not exist. Check to make sure the file path to your csv is correct."));
+            }
+        });
+        return this;
+    };
+    Converter.prototype.fromStream = function (readStream) {
+        readStream.pipe(this);
+        return this;
+    };
+    Converter.prototype.fromString = function (csvString) {
+        var csv = csvString.toString();
+        var read = new stream_1.Readable();
+        var idx = 0;
+        read._read = function (size) {
+            if (idx >= csvString.length) {
+                this.push(null);
+            }
+            else {
+                var str = csvString.substr(idx, size);
+                this.push(str);
+                idx += size;
+            }
+        };
+        return this.fromStream(read);
+    };
+    Converter.prototype.then = function (onfulfilled, onrejected) {
+        var _this = this;
+        return new bluebird_1.default(function (resolve, reject) {
+            _this.parseRuntime.then = {
+                onfulfilled: function (value) {
+                    if (onfulfilled) {
+                        resolve(onfulfilled(value));
+                    }
+                    else {
+                        resolve(value);
+                    }
+                },
+                onrejected: function (err) {
+                    if (onrejected) {
+                        resolve(onrejected(err));
+                    }
+                    else {
+                        reject(err);
+                    }
+                }
+            };
+        });
+    };
+    Object.defineProperty(Converter.prototype, "parseParam", {
+        get: function () {
+            return this.params;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Converter.prototype, "parseRuntime", {
+        get: function () {
+            return this.runtime;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Converter.prototype._transform = function (chunk, encoding, cb) {
+        var _this = this;
+        this.processor.process(chunk)
+            .then(function (result) {
+            // console.log(result);
+            if (result.length > 0) {
+                _this.runtime.started = true;
+                return _this.result.processResult(result);
+            }
+        })
+            .then(function () {
+            _this.emit("drained");
+            cb();
+        }, function (error) {
+            _this.runtime.hasError = true;
+            _this.runtime.error = error;
+            _this.emit("error", error);
+            cb();
+        });
+    };
+    Converter.prototype._flush = function (cb) {
+        var _this = this;
+        this.processor.flush()
+            .then(function (data) {
+            if (data.length > 0) {
+                return _this.result.processResult(data);
+            }
+        })
+            .then(function () {
+            _this.processEnd(cb);
+        }, function (err) {
+            _this.emit("error", err);
+            cb();
+        });
+    };
+    Converter.prototype.processEnd = function (cb) {
+        this.result.endProcess();
+        this.emit("done");
+        cb();
+    };
+    Object.defineProperty(Converter.prototype, "parsedLineNumber", {
+        get: function () {
+            return this.runtime.parsedLineNumber;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return Converter;
+}(stream_1.Transform));
+exports.Converter = Converter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/Converter.ts","sources":["/Users/kxiang/work/projects/csv2json/src/Converter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transform, TransformOptions, Readable } from \"stream\";\nimport { CSVParseParam, mergeParams } from \"./Parameters\";\nimport { ParseRuntime, initParseRuntime } from \"./ParseRuntime\";\nimport P from \"bluebird\";\nimport { stringToLines } from \"./fileline\";\nimport { map } from \"lodash/map\";\nimport { RowSplit, RowSplitResult } from \"./rowSplit\";\nimport getEol from \"./getEol\";\nimport lineToJson, { JSONResult } from \"./lineToJson\";\nimport { Processor, ProcessLineResult } from \"./Processor\";\n// import { ProcessorFork } from \"./ProcessFork\";\nimport { ProcessorLocal } from \"./ProcessorLocal\";\nimport { Result } from \"./Result\";\nimport CSVError from \"./CSVError\";\nimport { bufFromString } from \"./util\";\n\n\n\nexport class Converter extends Transform implements PromiseLike<any[]> {\n  preRawData(onRawData: PreRawDataCallback): Converter {\n    this.runtime.preRawDataHook = onRawData;\n    return this;\n  }\n  preFileLine(onFileLine: PreFileLineCallback): Converter {\n    this.runtime.preFileLineHook = onFileLine;\n    return this;\n  }\n  subscribe(\n    onNext?: (data: any, lineNumber: number) => void | PromiseLike<void>,\n    onError?: (err: CSVError) => void,\n    onCompleted?: () => void): Converter {\n    this.parseRuntime.subscribe = {\n      onNext,\n      onError,\n      onCompleted\n    }\n    return this;\n  }\n  fromFile(filePath: string, options?: string | CreateReadStreamOption | undefined): Converter {\n    const fs = require(\"fs\");\n    // var rs = null;\n    // this.wrapCallback(cb, function () {\n    //   if (rs && rs.destroy) {\n    //     rs.destroy();\n    //   }\n    // });\n    fs.exists(filePath, (exist) => {\n      if (exist) {\n        const rs = fs.createReadStream(filePath, options);\n        rs.pipe(this);\n      } else {\n        this.emit('error', new Error(\"File does not exist. Check to make sure the file path to your csv is correct.\"));\n      }\n    });\n    return this;\n  }\n  fromStream(readStream: Readable): Converter {\n    readStream.pipe(this);\n    return this;\n  }\n  fromString(csvString: string): Converter {\n    const csv = csvString.toString();\n    const read = new Readable();\n    let idx = 0;\n    read._read = function (size) {\n      if (idx >= csvString.length) {\n        this.push(null);\n      } else {\n        const str = csvString.substr(idx, size);\n        this.push(str);\n        idx += size;\n      }\n    }\n    return this.fromStream(read);\n  }\n  then<TResult1 = any[], TResult2 = never>(onfulfilled?: (value: any[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2> {\n    return new P((resolve, reject) => {\n      this.parseRuntime.then = {\n        onfulfilled: (value: any[]) => {\n          if (onfulfilled) {\n            resolve(onfulfilled(value));\n          } else {\n            resolve(value as any);\n          }\n        },\n        onrejected: (err: Error) => {\n          if (onrejected) {\n            resolve(onrejected(err));\n          } else {\n            reject(err);\n          }\n        }\n      }\n    });\n  }\n  public get parseParam(): CSVParseParam {\n    return this.params;\n  }\n  public get parseRuntime(): ParseRuntime {\n    return this.runtime;\n  }\n  private params: CSVParseParam;\n  private runtime: ParseRuntime;\n  private processor: Processor;\n  private result: Result;\n  constructor(param?: Partial<CSVParseParam>, public options: TransformOptions = {}) {\n    super(options);\n    this.params = mergeParams(param);\n    this.runtime = initParseRuntime(this);\n    this.result = new Result(this);\n    // if (this.params.fork) {\n    //   this.processor = new ProcessorFork(this);\n    // } else {\n    this.processor = new ProcessorLocal(this);\n    // }\n    this.once(\"error\", (err: any) => {\n      // console.log(\"BBB\");\n      //wait for next cycle to emit the errors.\n      setImmediate(() => {\n        this.result.processError(err);\n        this.emit(\"done\", err);\n      });\n\n    });\n    this.once(\"done\", () => {\n      this.processor.destroy();\n    })\n\n    return this;\n  }\n  _transform(chunk: any, encoding: string, cb: Function) {\n    this.processor.process(chunk)\n      .then((result) => {\n        // console.log(result);\n        if (result.length > 0) {\n          this.runtime.started = true;\n\n          return this.result.processResult(result);\n        }\n      })\n      .then(() => {\n        this.emit(\"drained\");\n        cb();\n      }, (error) => {\n        this.runtime.hasError = true;\n        this.runtime.error = error;\n        this.emit(\"error\", error);\n        cb();\n      });\n  }\n  _flush(cb: Function) {\n    this.processor.flush()\n      .then((data) => {\n        if (data.length > 0) {\n\n          return this.result.processResult(data);\n        }\n      })\n      .then(() => {\n        this.processEnd(cb);\n      }, (err) => {\n        this.emit(\"error\", err);\n        cb();\n      })\n  }\n  private processEnd(cb) {\n    this.result.endProcess();\n    this.emit(\"done\");\n    cb();\n  }\n  get parsedLineNumber(): number {\n    return this.runtime.parsedLineNumber;\n  }\n}\nexport interface CreateReadStreamOption {\n  flags?: string;\n  encoding?: string;\n  fd?: number;\n  mode?: number;\n  autoClose?: boolean;\n  start?: number;\n  end?: number;\n  highWaterMark?: number;\n}\nexport type CallBack = (err: Error, data: Array<any>) => void;\n\n\nexport type PreFileLineCallback = (line: string, lineNumber: number) => string | PromiseLike<string>;\nexport type PreRawDataCallback = (csvString: string) => string | PromiseLike<string>;\n"]}

.ts-node/4c960549d...6a34e2f38a490b8b82485bbbf319282a9c64.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Result_1 = require("./Result");
+var Converter_1 = require("./Converter");
+var path_1 = __importDefault(require("path"));
+var assert_1 = __importDefault(require("assert"));
+var dataDir = path_1.default.join(__dirname, "../test/data/");
+describe("Result", function () {
+    it("should return need push downstream based on needEmitAll parameter", function () {
+        var conv = new Converter_1.Converter();
+        var res = new Result_1.Result(conv);
+        assert_1.default.equal(res["needEmitAll"], false);
+        conv.then();
+        assert_1.default.equal(res["needEmitAll"], true);
+        conv.parseParam.needEmitAll = false;
+        assert_1.default.equal(res["needEmitAll"], false);
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/4c960549d...739b703649046edb8805d043fd9d43e23581.js

+"use strict";
+// import {Converter} from "../src/Converter";
+// import csv from "../src";
+// var assert = require("assert");
+// var fs = require("fs");
+// var sandbox = require("sinon").sandbox.create();
+// var file = __dirname + "/data/testData";
+// var trailCommaData = __dirname + "/data/trailingComma";
+// describe("CSV Convert in Background Process", function () {
+//   afterEach(function () {
+//     sandbox.restore();
+//   });
+//   it("should read from a stream", function (done) {
+//     var obj = new Converter({
+//       fork: true
+//     });
+//     var stream = fs.createReadStream(file);
+//     obj.then(function (obj) {
+//       assert.equal(obj.length, 2);
+//       done();
+//     },(err)=>{
+//       console.log(err.toString());
+//     });
+//     stream.pipe(obj);
+//   });
+//   it("should call onNext once a row is parsed.", function (done) {
+//     var obj = new Converter({fork:true});
+//     var stream = fs.createReadStream(file);
+//     var called = false;
+//     obj.subscribe(function (resultRow) {
+//       assert(resultRow);
+//       called = true;
+//     });
+//     obj.on("done", function () {
+//       assert(called);
+//       done();
+//     });
+//     stream.pipe(obj);
+//   });
+//   it("should emit end_parsed message once it is finished.", function (done) {
+//     var obj = new Converter({fork:true});
+//     obj.then(function (result) {
+//       assert(result);
+//       assert(result.length === 2);
+//       assert(result[0].date);
+//       assert(result[0].employee);
+//       assert(result[0].employee.name);
+//       assert(result[0].employee.age);
+//       assert(result[0].employee.number);
+//       assert(result[0].employee.key.length === 2);
+//       assert(result[0].address.length === 2);
+//       done();
+//     });
+//     fs.createReadStream(file).pipe(obj);
+//   });
+//   it("should handle traling comma gracefully", function (done) {
+//     var stream = fs.createReadStream(trailCommaData);
+//     var obj = new Converter({fork:true});
+//     obj.then(function (result) {
+//       assert(result);
+//       assert(result.length > 0);
+//       done();
+//     });
+//     stream.pipe(obj);
+//   });
+//   it("should handle comma in column which is surrounded by qoutes", function (done) {
+//     var testData = __dirname + "/data/dataWithComma";
+//     var rs = fs.createReadStream(testData);
+//     var obj = new Converter({
+//       "quote": "#",
+//       "fork":true
+//     });
+//     obj.then(function (result) {
+//       assert(result[0].col1 === "\"Mini. Sectt");
+//       assert.equal(result[3].col2, "125001,fenvkdsf");
+//       // console.log(result);
+//       done();
+//     });
+//     rs.pipe(obj);
+//   });
+//   it("should be able to convert a csv to column array data", function (done) {
+//     var columArrData = __dirname + "/data/columnArray";
+//     var rs = fs.createReadStream(columArrData);
+//     var result:any = {};
+//     var csvConverter = new Converter({fork:true});
+//     //end_parsed will be emitted once parsing finished
+//     csvConverter.then(function () {
+//       assert(result.TIMESTAMP.length === 5);
+//       done();
+//     });
+//     //record_parsed will be emitted each time a row has been parsed.
+//     csvConverter.subscribe(function (resultRow, rowIndex) {
+//       for (var key in resultRow) {
+//         if (resultRow.hasOwnProperty(key)) {
+//           if (!result[key] || !(result[key] instanceof Array)) {
+//             result[key] = [];
+//           }
+//           result[key][rowIndex] = resultRow[key];
+//         }
+//       }
+//     });
+//     rs.pipe(csvConverter);
+//   });
+//   it("should be able to convert csv string directly", function (done) {
+//     var testData = __dirname + "/data/testData";
+//     var data = fs.readFileSync(testData).toString();
+//     var csvConverter = new Converter({fork:true});
+//     //end_parsed will be emitted once parsing finished
+//     csvConverter.then(function (jsonObj) {
+//       assert.equal(jsonObj.length, 2);
+//     });
+//     csvConverter.fromString(data).then(function (jsonObj) {
+//       assert(jsonObj.length === 2);
+//       done();
+//     });
+//   });
+//   it("should be able to convert csv string with error", function (done) {
+//     var testData = __dirname + "/data/dataWithUnclosedQuotes";
+//     var data = fs.readFileSync(testData).toString();
+//     var csvConverter = new Converter({fork:true});
+//     csvConverter.fromString(data).then(undefined, function (err) {
+//       // console.log(err);
+//       assert(err);
+//       assert.equal(err.err, "unclosed_quote");
+//       done();
+//     });
+//   });
+//   it("should be able to convert csv string without callback provided", function (done) {
+//     var testData = __dirname + "/data/testData";
+//     var data = fs.readFileSync(testData).toString();
+//     var csvConverter = new Converter({fork:true});
+//     //end_parsed will be emitted once parsing finished
+//     csvConverter.then(function (jsonObj) {
+//       assert(jsonObj.length === 2);
+//       done();
+//     });
+//     csvConverter.fromString(data);
+//   });
+//   it("should be able to handle columns with double quotes", function (done) {
+//     var testData = __dirname + "/data/dataWithQoutes";
+//     var data = fs.readFileSync(testData).toString();
+//     var csvConverter = new Converter({fork:true});
+//     csvConverter.fromString(data).then(function (jsonObj) {
+//       assert(jsonObj[0].TIMESTAMP === '13954264"22', JSON.stringify(jsonObj[0].TIMESTAMP));
+//       assert(jsonObj[1].TIMESTAMP === 'abc, def, ccc', JSON.stringify(jsonObj[1].TIMESTAMP));
+//       done();
+//     });
+//   });
+//   it("should be able to handle columns with two double quotes", function (done) {
+//     var testData = __dirname + "/data/twodoublequotes";
+//     var data = fs.readFileSync(testData).toString();
+//     var csvConverter = new Converter({fork:true});
+//     csvConverter.fromString(data).then(function (jsonObj) {
+//       assert.equal(jsonObj[0].title, "\"");
+//       assert.equal(jsonObj[0].data, "xyabcde");
+//       assert.equal(jsonObj[0].uuid, "fejal\"eifa");
+//       assert.equal(jsonObj[0].fieldA, "bnej\"\"falkfe");
+//       assert.equal(jsonObj[0].fieldB, "\"eisjfes\"");
+//       done();
+//     });
+//   });
+//   it("should handle empty csv file", function (done) {
+//     var testData = __dirname + "/data/emptyFile";
+//     var rs = fs.createReadStream(testData);
+//     var csvConverter = new Converter({fork:true});
+//     csvConverter.then(function (jsonObj) {
+//       assert(jsonObj.length === 0);
+//       done();
+//     });
+//     rs.pipe(csvConverter);
+//   });
+//   it("should parse large csv file", function (done) {
+//     var testData = __dirname + "/data/large-csv-sample.csv";
+//     var rs = fs.createReadStream(testData);
+//     var csvConverter = new Converter({fork:true});
+//     var count = 0;
+//     csvConverter.subscribe(function () {
+//       // console.log(arguments);
+//       count++;
+//     });
+//     csvConverter.then(function () {
+//       assert.equal(count, 5290);
+//       done();
+//     });
+//     rs.pipe(csvConverter);
+//   });
+//   it("should parse data and covert to specific types", function (done) {
+//     var testData = __dirname + "/data/dataWithType";
+//     var rs = fs.createReadStream(testData);
+//     var csvConverter = new Converter({
+//       fork:true,
+//       checkType: true,
+//       colParser: {
+//         "column6": "string",
+//         "column7": "string"
+//       }
+//     });
+//     csvConverter.subscribe(function (d) {
+//       assert(typeof d.column1 === "number");
+//       assert(typeof d.column2 === "string");
+//       assert.equal(d["colume4"], "someinvaliddate");
+//       assert(d.column5.hello === "world");
+//       assert(d.column6 === '{"hello":"world"}');
+//       assert(d.column7 === "1234");
+//       assert(d.column8 === "abcd");
+//       assert(d.column9 === true);
+//       assert(d.column10[0] === 23);
+//       assert(d.column10[1] === 31);
+//       assert(d.column11[0].hello === "world");
+//       assert(d["name#!"] === false);
+//     });
+//     csvConverter.on("done", function () {
+//       done();
+//     });
+//     rs.pipe(csvConverter);
+//   });
+//   it("should turn off field type check", function (done) {
+//     var testData = __dirname + "/data/dataWithType";
+//     var rs = fs.createReadStream(testData);
+//     var csvConverter = new Converter({
+//       fork:true,
+//       checkType: false
+//     });
+//     csvConverter.subscribe(function (d) {
+//       assert(typeof d.column1 === "string");
+//       assert(typeof d.column2 === "string");
+//       assert(d["column3"] === "2012-01-01");
+//       assert(d["colume4"] === "someinvaliddate");
+//       assert(d.column5 === '{"hello":"world"}');
+//       assert.equal(d["column6"], '{"hello":"world"}');
+//       assert(d["column7"] === "1234");
+//       assert(d["column8"] === "abcd");
+//       assert(d.column9 === "true");
+//       assert(d.column10[0] === "23");
+//       assert(d.column10[1] === "31");
+//       assert(d["name#!"] === 'false');
+//     });
+//     csvConverter.then(function () {
+//       done();
+//     });
+//     rs.pipe(csvConverter);
+//   });
+//   it("should emit data event correctly", function (done) {
+//     var testData = __dirname + "/data/large-csv-sample.csv";
+//     var csvConverter = new Converter({
+//       fork:true
+//     },{objectMode:true});
+//     var count = 0;
+//     csvConverter.on("data", function (d) {
+//       count++;
+//     });
+//     csvConverter.on("done", function () {
+//       assert.equal(csvConverter.parsedLineNumber, 5290);
+//       done();
+//     });
+//     var rs = fs.createReadStream(testData);
+//     rs.pipe(csvConverter);
+//   });
+//   it("should process column with linebreaks", function (done) {
+//     var testData = __dirname + "/data/lineBreak";
+//     var rs = fs.createReadStream(testData);
+//     var csvConverter = new Converter({
+//       fork:true,
+//       checkType: true
+//     });
+//     csvConverter.subscribe(function (d) {
+//       assert(d.Period === 13);
+//       assert(d["Apparent age"] === "Unknown");
+//       done();
+//     });
+//     rs.pipe(csvConverter);
+//   });
+//   it("be able to ignore empty columns", function (done) {
+//     var testData = __dirname + "/data/dataIgnoreEmpty";
+//     var rs = fs.createReadStream(testData);
+//     var st = rs.pipe(csv({ 
+//       ignoreEmpty: true ,
+//       fork:true
+//     }));
+//     st.then(function (res) {
+//       var j = res[0];
+//       assert(res.length === 3);
+//       assert(j.col2.length === 2);
+//       assert(j.col2[1] === "d3");
+//       assert(j.col4.col3 === undefined);
+//       assert(j.col4.col5 === "world");
+//       assert(res[1].col1 === "d2");
+//       assert(res[2].col1 === "d4");
+//       done();
+//     });
+//   });
+//   it("should allow no header", function (done) {
+//     var testData = __dirname + "/data/noheadercsv";
+//     var rs = fs.createReadStream(testData);
+//     var st = rs.pipe(new Converter({ 
+//       noheader: true,
+//       fork:true
+//     }));
+//     st.then(function (res) {
+//       var j = res[0];
+//       assert(res.length === 5);
+//       assert(j.field1 === "CC102-PDMI-001");
+//       assert(j.field2 === "eClass_5.1.3");
+//       done();
+//     });
+//   });
+//   it("should allow customised header", function (done) {
+//     var testData = __dirname + "/data/noheadercsv";
+//     var rs = fs.createReadStream(testData);
+//     var st = rs.pipe(new Converter({
+//       noheader: true,
+//       headers: ["a", "b"],
+//       fork:true
+//     }));
+//     st.then(function (res) {
+//       var j = res[0];
+//       assert(res.length === 5);
+//       assert(j.a === "CC102-PDMI-001");
+//       assert(j.b === "eClass_5.1.3");
+//       assert(j.field3 === "10/3/2014");
+//       done();
+//     });
+//   });
+//   it("should allow customised header to override existing header", function (done) {
+//     var testData = __dirname + "/data/complexJSONCSV";
+//     var rs = fs.createReadStream(testData);
+//     var st = rs.pipe(new Converter({
+//       headers: [],
+//       fork:true
+//     }));
+//     st.then(function (res) {
+//       var j = res[0];
+//       assert(res.length === 2);
+//       assert(j.field1 === "Food Factory");
+//       assert(j.field2 === "Oscar");
+//       done();
+//     });
+//   });
+//   it("should handle when there is an empty string", function (done) {
+//     var testData = __dirname + "/data/dataWithEmptyString";
+//     var rs = fs.createReadStream(testData);
+//     var st = rs.pipe(new Converter({
+//       noheader: true,
+//       headers: ["a", "b", "c"],
+//       checkType: true,
+//       fork:true
+//     }));
+//     st.then(function (res) {
+//       var j = res[0];
+//       // assert(res.length===2);
+//       assert(j.a === "green");
+//       assert(j.b === 40);
+//       assert.equal(j.c, "");
+//       done();
+//     });
+//   });
+//   it("should detect eol correctly when first chunk is smaller than header row length", function (done) {
+//     var testData = __dirname + "/data/dataNoTrimCRLF";
+//     var rs = fs.createReadStream(testData, { highWaterMark: 3 });
+//     var st = rs.pipe(new Converter({
+//       trim: false,
+//       fork:true
+//     }));
+//     st.then(function (res) {
+//       var j = res[0];
+//       assert(res.length === 2);
+//       assert(j.name === "joe");
+//       assert(j.age === "20");
+//       assert.equal(res[1].name, "sam");
+//       assert.equal(res[1].age, "30");
+//       done();
+//     });
+//   });
+//   it("should detect eol correctly when first chunk ends in middle of CRLF line break", function (done) {
+//     var testData = __dirname + "/data/dataNoTrimCRLF";
+//     var rs = fs.createReadStream(testData, { highWaterMark: 9 });
+//     var st = rs.pipe(new Converter({
+//       trim: false,
+//       fork:true
+//     }));
+//     st.then(function (res) {
+//       var j = res[0];
+//       assert(res.length === 2);
+//       assert(j.name === "joe");
+//       assert(j.age === "20");
+//       assert.equal(res[1].name, "sam");
+//       assert.equal(res[1].age, "30");
+//       done();
+//     });
+//   });
+//   it("should emit eol event when line ending is detected as CRLF", function (done) {
+//     var testData = __dirname + "/data/dataNoTrimCRLF";
+//     var rs = fs.createReadStream(testData);
+//     var st = rs.pipe(new Converter({
+//       fork:true
+//     }));
+//     var eolCallback = sandbox.spy(function (eol) {
+//       assert.equal(eol, "\r\n");
+//     });
+//     st.on("eol", eolCallback);
+//     st.then(function () {
+//       assert.equal(eolCallback.callCount, 1, 'should emit eol event once');
+//       done();
+//     })
+//   });
+//   it("should emit eol event when line ending is detected as LF", function (done) {
+//     var testData = __dirname + "/data/columnArray";
+//     var rs = fs.createReadStream(testData);
+//     var st = rs.pipe(new Converter({
+//       fork:true
+//     }));
+//     var eolCallback = sandbox.spy(function (eol) {
+//       assert.equal(eol, "\n");
+//     });
+//     st.on("eol", eolCallback);
+//     st.then(function () {
+//       assert.equal(eolCallback.callCount, 1, 'should emit eol event once');
+//       done();
+//     })
+//   });
+//   it("should remove the Byte Order Mark (BOM) from input", function (done) {
+//     var testData = __dirname + "/data/dataNoTrimBOM";
+//     var rs = fs.createReadStream(testData);
+//     var st = rs.pipe(new Converter({
+//       trim: false,
+//       fork:true
+//     }));
+//     st.then( function (res) {
+//       var j = res[0];
+//       assert(res.length===2);
+//       assert(j.name === "joe");
+//       assert(j.age === "20");
+//       done();
+//     });
+//   });
+//   it("should set output as csv", function (done) {
+//     var testData = __dirname + "/data/complexJSONCSV";
+//     var rs = fs.createReadStream(testData);
+//     var numOfRow = 0;
+//     csv({ output: "csv",fork:true })
+//       .fromStream(rs)
+//       .subscribe(function (row, idx) {
+//         numOfRow++;
+//         assert(row);
+//         assert(idx >= 0);
+//       })
+//       .on("done", function (error) {
+//         assert(!error);
+//         assert.equal(2, numOfRow);
+//         assert(numOfRow !== 0);
+//         done();
+//       });
+//   });
+//   it("should process long header", function (done) {
+//     var testData = __dirname + "/data/longHeader";
+//     var rs = fs.createReadStream(testData, { highWaterMark: 100 });
+//     var numOfRow = 0;
+//     var numOfJson = 0;
+//     csv({fork:true}, { highWaterMark: 100 })
+//       .fromStream(rs)
+//       .subscribe(function (res, idx) {
+//         numOfJson++;
+//         assert.equal(res.Date, '8/26/16');
+//         assert(idx >= 0);
+//       })
+//       .on("done", function () {
+//         assert(numOfJson === 1);
+//         done();
+//       });
+//   });
+//   it("should parse #139", function (done) {
+//     var rs = fs.createReadStream(__dirname + "/data/data#139");
+//     csv({fork:true})
+//       .fromStream(rs)
+//       .then(function (res) {
+//         assert.equal(res[1].field3, "9001009395 9001009990");
+//         done();
+//       });
+//   });
+//   it("should ignore column", function (done) {
+//     var rs = fs.createReadStream(__dirname + "/data/dataWithQoutes");
+//     var headerEmitted = false;
+//     csv({
+//       ignoreColumns: /TIMESTAMP/,
+//       fork:true
+//     })
+//       .fromStream(rs)
+//       .on("header", function (header) {
+//         assert.equal(header.indexOf("TIMESTAMP"), -1);
+//         assert.equal(header.indexOf("UPDATE"), 0);
+//         if (headerEmitted) {
+//           throw ("header event should only happen once")
+//         }
+//         headerEmitted = true;
+//       })
+//       // .on("csv", function (row, idx) {
+//       //   if (!headerEmitted) {
+//       //     throw ("header should be emitted before any data events");
+//       //   }
+//       //   assert(idx >= 0);
+//       //   if (idx === 1) {
+//       //     assert.equal(row[0], "n");
+//       //   }
+//       // })
+//       .subscribe(function (j, idx) {
+//         // console.log(j);
+//         assert(!j.TIMESTAMP);
+//         assert(idx >= 0);
+//       })
+//       .on("done", function (err) {
+//         assert(!err);
+//         assert(headerEmitted);
+//         done();
+//       });
+//   });
+//   it("should include column", function (done) {
+//     var rs = fs.createReadStream(__dirname + "/data/dataWithQoutes");
+//     csv({
+//       includeColumns: /TIMESTAMP/,
+//       fork:true
+//     })
+//       .fromStream(rs)
+//       .on("header", function (header) {
+//         assert.equal(header.indexOf("TIMESTAMP"), 0);
+//         assert.equal(header.indexOf("UPDATE"), -1);
+//         assert.equal(header.length, 1);
+//       })
+//       .subscribe(function (j, idx) {
+//         assert(idx >= 0);
+//         if (idx === 1) {
+//           assert.equal(j.TIMESTAMP, "abc, def, ccc");
+//         }
+//         assert(!j.UID)
+//         assert(!j['BYTES SENT'])
+//       })
+//       .on("done", function () {
+//         done();
+//       });
+//   });
+//   it("should allow headers and include columns to be given as reference to the same var", function (done) {
+//     var rs = fs.createReadStream(__dirname + "/data/complexJSONCSV");
+//     var headers = [
+//       'first',
+//       'second',
+//       'third',
+//     ];
+//     var expected = headers;
+//     csv({
+//       headers: headers,
+//       includeColumns: /(first|second|third)/,
+//       fork:true
+//     })
+//       .fromStream(rs)
+//       .on("header", function (header) {
+//         expected.forEach(function (value, index) {
+//           assert.equal(header.indexOf(value), index);
+//         });
+//       })
+//       .subscribe(function (j, idx) {
+//         assert(idx >= 0);
+//         assert.equal(expected.length, Object.keys(j).length);
+//         expected.forEach(function (attribute) {
+//           assert(j.hasOwnProperty(attribute));
+//         });
+//       })
+//       .on("done", function () {
+//         done();
+//       });
+//   });
+//   it("should leave provided params objects unmutated", function() {
+//     var rs = fs.createReadStream(__dirname + "/data/complexJSONCSV");
+//     var includeColumns = [
+//       'fieldA.title',
+//       'description',
+//     ];
+//     return csv({
+//       includeColumns: /(fieldA\.title|description)/,
+//       fork:true
+//     })
+//       .fromStream(rs)
+//       .on("json", function(j, idx) {
+//         assert(idx >= 0);
+//       })
+//       .on("header", function(header) {
+//         includeColumns.forEach(function (value, index) {
+//           assert.equal(index, header.indexOf(value));
+//         });
+//       })
+//   });
+//   it("should accept pipe as quote", function (done) {
+//     csv({
+//       quote: "|",
+//       output: "csv",
+//       "fork":true
+//     })
+//       .fromFile(__dirname + "/data/pipeAsQuote")
+//       .subscribe(function (csv) {
+//         assert.equal(csv[2], "blahhh, blah");
+//       })
+//       .on('done', function () {
+//         done()
+//       });
+//   })
+//   it("should allow async subscribe function", () => {
+//     return csv({ trim: true,fork:true })
+//       .fromString(`a,b,c
+//     1,2,3
+//     4,5,6`)
+//       .subscribe((d) => {
+//         return new Promise((resolve, reject) => {
+//           setTimeout(() => {
+//             d.a = 10;
+//             resolve();
+//           }, 20);
+//         })
+//       })
+//       .then((d) => {
+//         assert.equal(d[0].a, 10);
+//         assert.equal(d[1].a, 10);
+//       })
+//   })
+//   it("should omit a column", () => {
+//     return csv({
+//       colParser: {
+//         "a": "omit"
+//       },
+//       fork:true
+//     })
+//       .fromString(`a,b,c
+//   1,2,3
+//   fefe,5,6`)
+//       .then((d) => {
+//         assert.strictEqual(d[0].a, undefined);
+//         assert.equal(d[1].a, undefined);
+//       })
+//   })
+// });
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/test/testCSVConverter.fork.ts","sources":["/Users/kxiang/work/projects/csv2json/test/testCSVConverter.fork.ts"],"names":[],"mappings":"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","sourcesContent":["// import {Converter} from \"../src/Converter\";\n// import csv from \"../src\";\n// var assert = require(\"assert\");\n// var fs = require(\"fs\");\n// var sandbox = require(\"sinon\").sandbox.create();\n// var file = __dirname + \"/data/testData\";\n// var trailCommaData = __dirname + \"/data/trailingComma\";\n// describe(\"CSV Convert in Background Process\", function () {\n//   afterEach(function () {\n//     sandbox.restore();\n//   });\n\n\n//   it(\"should read from a stream\", function (done) {\n//     var obj = new Converter({\n//       fork: true\n//     });\n//     var stream = fs.createReadStream(file);\n//     obj.then(function (obj) {\n//       assert.equal(obj.length, 2);\n//       done();\n//     },(err)=>{\n//       console.log(err.toString());\n//     });\n//     stream.pipe(obj);\n//   });\n\n//   it(\"should call onNext once a row is parsed.\", function (done) {\n//     var obj = new Converter({fork:true});\n//     var stream = fs.createReadStream(file);\n//     var called = false;\n//     obj.subscribe(function (resultRow) {\n//       assert(resultRow);\n//       called = true;\n//     });\n//     obj.on(\"done\", function () {\n//       assert(called);\n//       done();\n//     });\n//     stream.pipe(obj);\n//   });\n\n//   it(\"should emit end_parsed message once it is finished.\", function (done) {\n//     var obj = new Converter({fork:true});\n//     obj.then(function (result) {\n//       assert(result);\n//       assert(result.length === 2);\n//       assert(result[0].date);\n//       assert(result[0].employee);\n//       assert(result[0].employee.name);\n//       assert(result[0].employee.age);\n//       assert(result[0].employee.number);\n//       assert(result[0].employee.key.length === 2);\n//       assert(result[0].address.length === 2);\n//       done();\n//     });\n//     fs.createReadStream(file).pipe(obj);\n//   });\n\n//   it(\"should handle traling comma gracefully\", function (done) {\n//     var stream = fs.createReadStream(trailCommaData);\n//     var obj = new Converter({fork:true});\n//     obj.then(function (result) {\n//       assert(result);\n//       assert(result.length > 0);\n//       done();\n//     });\n//     stream.pipe(obj);\n//   });\n\n//   it(\"should handle comma in column which is surrounded by qoutes\", function (done) {\n//     var testData = __dirname + \"/data/dataWithComma\";\n//     var rs = fs.createReadStream(testData);\n//     var obj = new Converter({\n//       \"quote\": \"#\",\n//       \"fork\":true\n//     });\n//     obj.then(function (result) {\n//       assert(result[0].col1 === \"\\\"Mini. Sectt\");\n//       assert.equal(result[3].col2, \"125001,fenvkdsf\");\n//       // console.log(result);\n//       done();\n//     });\n//     rs.pipe(obj);\n//   });\n\n//   it(\"should be able to convert a csv to column array data\", function (done) {\n//     var columArrData = __dirname + \"/data/columnArray\";\n//     var rs = fs.createReadStream(columArrData);\n//     var result:any = {};\n//     var csvConverter = new Converter({fork:true});\n//     //end_parsed will be emitted once parsing finished\n//     csvConverter.then(function () {\n//       assert(result.TIMESTAMP.length === 5);\n//       done();\n//     });\n\n//     //record_parsed will be emitted each time a row has been parsed.\n//     csvConverter.subscribe(function (resultRow, rowIndex) {\n//       for (var key in resultRow) {\n//         if (resultRow.hasOwnProperty(key)) {\n//           if (!result[key] || !(result[key] instanceof Array)) {\n//             result[key] = [];\n//           }\n//           result[key][rowIndex] = resultRow[key];\n//         }\n//       }\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should be able to convert csv string directly\", function (done) {\n//     var testData = __dirname + \"/data/testData\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     //end_parsed will be emitted once parsing finished\n//     csvConverter.then(function (jsonObj) {\n//       assert.equal(jsonObj.length, 2);\n//     });\n//     csvConverter.fromString(data).then(function (jsonObj) {\n//       assert(jsonObj.length === 2);\n//       done();\n//     });\n//   });\n\n//   it(\"should be able to convert csv string with error\", function (done) {\n//     var testData = __dirname + \"/data/dataWithUnclosedQuotes\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     csvConverter.fromString(data).then(undefined, function (err) {\n//       // console.log(err);\n//       assert(err);\n//       assert.equal(err.err, \"unclosed_quote\");\n//       done();\n//     });\n//   });\n\n//   it(\"should be able to convert csv string without callback provided\", function (done) {\n//     var testData = __dirname + \"/data/testData\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     //end_parsed will be emitted once parsing finished\n//     csvConverter.then(function (jsonObj) {\n//       assert(jsonObj.length === 2);\n//       done();\n//     });\n//     csvConverter.fromString(data);\n//   });\n\n//   it(\"should be able to handle columns with double quotes\", function (done) {\n//     var testData = __dirname + \"/data/dataWithQoutes\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     csvConverter.fromString(data).then(function (jsonObj) {\n//       assert(jsonObj[0].TIMESTAMP === '13954264\"22', JSON.stringify(jsonObj[0].TIMESTAMP));\n\n//       assert(jsonObj[1].TIMESTAMP === 'abc, def, ccc', JSON.stringify(jsonObj[1].TIMESTAMP));\n//       done();\n//     });\n//   });\n\n//   it(\"should be able to handle columns with two double quotes\", function (done) {\n//     var testData = __dirname + \"/data/twodoublequotes\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     csvConverter.fromString(data).then(function (jsonObj) {\n//       assert.equal(jsonObj[0].title, \"\\\"\");\n//       assert.equal(jsonObj[0].data, \"xyabcde\");\n//       assert.equal(jsonObj[0].uuid, \"fejal\\\"eifa\");\n//       assert.equal(jsonObj[0].fieldA, \"bnej\\\"\\\"falkfe\");\n//       assert.equal(jsonObj[0].fieldB, \"\\\"eisjfes\\\"\");\n//       done();\n//     });\n//   });\n\n//   it(\"should handle empty csv file\", function (done) {\n//     var testData = __dirname + \"/data/emptyFile\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({fork:true});\n//     csvConverter.then(function (jsonObj) {\n//       assert(jsonObj.length === 0);\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should parse large csv file\", function (done) {\n//     var testData = __dirname + \"/data/large-csv-sample.csv\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({fork:true});\n//     var count = 0;\n//     csvConverter.subscribe(function () {\n//       // console.log(arguments);\n//       count++;\n//     });\n//     csvConverter.then(function () {\n//       assert.equal(count, 5290);\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should parse data and covert to specific types\", function (done) {\n//     var testData = __dirname + \"/data/dataWithType\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({\n//       fork:true,\n//       checkType: true,\n//       colParser: {\n//         \"column6\": \"string\",\n//         \"column7\": \"string\"\n//       }\n//     });\n//     csvConverter.subscribe(function (d) {\n//       assert(typeof d.column1 === \"number\");\n//       assert(typeof d.column2 === \"string\");\n//       assert.equal(d[\"colume4\"], \"someinvaliddate\");\n//       assert(d.column5.hello === \"world\");\n//       assert(d.column6 === '{\"hello\":\"world\"}');\n//       assert(d.column7 === \"1234\");\n//       assert(d.column8 === \"abcd\");\n//       assert(d.column9 === true);\n//       assert(d.column10[0] === 23);\n//       assert(d.column10[1] === 31);\n//       assert(d.column11[0].hello === \"world\");\n//       assert(d[\"name#!\"] === false);\n//     });\n//     csvConverter.on(\"done\", function () {\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should turn off field type check\", function (done) {\n//     var testData = __dirname + \"/data/dataWithType\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({\n//       fork:true,\n//       checkType: false\n//     });\n//     csvConverter.subscribe(function (d) {\n//       assert(typeof d.column1 === \"string\");\n//       assert(typeof d.column2 === \"string\");\n//       assert(d[\"column3\"] === \"2012-01-01\");\n//       assert(d[\"colume4\"] === \"someinvaliddate\");\n//       assert(d.column5 === '{\"hello\":\"world\"}');\n//       assert.equal(d[\"column6\"], '{\"hello\":\"world\"}');\n//       assert(d[\"column7\"] === \"1234\");\n//       assert(d[\"column8\"] === \"abcd\");\n//       assert(d.column9 === \"true\");\n//       assert(d.column10[0] === \"23\");\n//       assert(d.column10[1] === \"31\");\n//       assert(d[\"name#!\"] === 'false');\n//     });\n//     csvConverter.then(function () {\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should emit data event correctly\", function (done) {\n//     var testData = __dirname + \"/data/large-csv-sample.csv\";\n\n//     var csvConverter = new Converter({\n//       fork:true\n//     },{objectMode:true});\n//     var count = 0;\n//     csvConverter.on(\"data\", function (d) {\n//       count++;\n//     });\n//     csvConverter.on(\"done\", function () {\n//       assert.equal(csvConverter.parsedLineNumber, 5290);\n//       done();\n//     });\n//     var rs = fs.createReadStream(testData);\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should process column with linebreaks\", function (done) {\n//     var testData = __dirname + \"/data/lineBreak\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({\n//       fork:true,\n//       checkType: true\n//     });\n//     csvConverter.subscribe(function (d) {\n//       assert(d.Period === 13);\n//       assert(d[\"Apparent age\"] === \"Unknown\");\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"be able to ignore empty columns\", function (done) {\n//     var testData = __dirname + \"/data/dataIgnoreEmpty\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(csv({ \n//       ignoreEmpty: true ,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 3);\n//       assert(j.col2.length === 2);\n//       assert(j.col2[1] === \"d3\");\n//       assert(j.col4.col3 === undefined);\n//       assert(j.col4.col5 === \"world\");\n//       assert(res[1].col1 === \"d2\");\n//       assert(res[2].col1 === \"d4\");\n//       done();\n//     });\n//   });\n\n//   it(\"should allow no header\", function (done) {\n//     var testData = __dirname + \"/data/noheadercsv\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({ \n//       noheader: true,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 5);\n//       assert(j.field1 === \"CC102-PDMI-001\");\n//       assert(j.field2 === \"eClass_5.1.3\");\n//       done();\n//     });\n//   });\n\n//   it(\"should allow customised header\", function (done) {\n//     var testData = __dirname + \"/data/noheadercsv\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({\n//       noheader: true,\n//       headers: [\"a\", \"b\"],\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 5);\n//       assert(j.a === \"CC102-PDMI-001\");\n//       assert(j.b === \"eClass_5.1.3\");\n//       assert(j.field3 === \"10/3/2014\");\n//       done();\n//     });\n//   });\n\n//   it(\"should allow customised header to override existing header\", function (done) {\n//     var testData = __dirname + \"/data/complexJSONCSV\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({\n//       headers: [],\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 2);\n//       assert(j.field1 === \"Food Factory\");\n//       assert(j.field2 === \"Oscar\");\n//       done();\n//     });\n//   });\n\n//   it(\"should handle when there is an empty string\", function (done) {\n//     var testData = __dirname + \"/data/dataWithEmptyString\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({\n//       noheader: true,\n//       headers: [\"a\", \"b\", \"c\"],\n//       checkType: true,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n\n//       // assert(res.length===2);\n//       assert(j.a === \"green\");\n//       assert(j.b === 40);\n//       assert.equal(j.c, \"\");\n//       done();\n//     });\n//   });\n\n//   it(\"should detect eol correctly when first chunk is smaller than header row length\", function (done) {\n//     var testData = __dirname + \"/data/dataNoTrimCRLF\";\n//     var rs = fs.createReadStream(testData, { highWaterMark: 3 });\n\n//     var st = rs.pipe(new Converter({\n//       trim: false,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 2);\n//       assert(j.name === \"joe\");\n//       assert(j.age === \"20\");\n//       assert.equal(res[1].name, \"sam\");\n//       assert.equal(res[1].age, \"30\");\n//       done();\n//     });\n//   });\n\n//   it(\"should detect eol correctly when first chunk ends in middle of CRLF line break\", function (done) {\n//     var testData = __dirname + \"/data/dataNoTrimCRLF\";\n//     var rs = fs.createReadStream(testData, { highWaterMark: 9 });\n\n//     var st = rs.pipe(new Converter({\n//       trim: false,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 2);\n//       assert(j.name === \"joe\");\n//       assert(j.age === \"20\");\n//       assert.equal(res[1].name, \"sam\");\n//       assert.equal(res[1].age, \"30\");\n//       done();\n//     });\n//   });\n\n//   it(\"should emit eol event when line ending is detected as CRLF\", function (done) {\n//     var testData = __dirname + \"/data/dataNoTrimCRLF\";\n//     var rs = fs.createReadStream(testData);\n\n//     var st = rs.pipe(new Converter({\n//       fork:true\n//     }));\n//     var eolCallback = sandbox.spy(function (eol) {\n//       assert.equal(eol, \"\\r\\n\");\n//     });\n//     st.on(\"eol\", eolCallback);\n//     st.then(function () {\n//       assert.equal(eolCallback.callCount, 1, 'should emit eol event once');\n//       done();\n//     })\n//   });\n\n//   it(\"should emit eol event when line ending is detected as LF\", function (done) {\n//     var testData = __dirname + \"/data/columnArray\";\n//     var rs = fs.createReadStream(testData);\n\n//     var st = rs.pipe(new Converter({\n//       fork:true\n//     }));\n//     var eolCallback = sandbox.spy(function (eol) {\n//       assert.equal(eol, \"\\n\");\n//     });\n//     st.on(\"eol\", eolCallback);\n//     st.then(function () {\n//       assert.equal(eolCallback.callCount, 1, 'should emit eol event once');\n//       done();\n//     })\n//   });\n\n//   it(\"should remove the Byte Order Mark (BOM) from input\", function (done) {\n//     var testData = __dirname + \"/data/dataNoTrimBOM\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({\n//       trim: false,\n//       fork:true\n//     }));\n//     st.then( function (res) {\n//       var j = res[0];\n\n//       assert(res.length===2);\n//       assert(j.name === \"joe\");\n//       assert(j.age === \"20\");\n//       done();\n//     });\n//   });\n\n//   it(\"should set output as csv\", function (done) {\n//     var testData = __dirname + \"/data/complexJSONCSV\";\n//     var rs = fs.createReadStream(testData);\n//     var numOfRow = 0;\n//     csv({ output: \"csv\",fork:true })\n//       .fromStream(rs)\n//       .subscribe(function (row, idx) {\n//         numOfRow++;\n//         assert(row);\n//         assert(idx >= 0);\n//       })\n\n//       .on(\"done\", function (error) {\n//         assert(!error);\n//         assert.equal(2, numOfRow);\n//         assert(numOfRow !== 0);\n//         done();\n//       });\n//   });\n//   it(\"should process long header\", function (done) {\n//     var testData = __dirname + \"/data/longHeader\";\n//     var rs = fs.createReadStream(testData, { highWaterMark: 100 });\n//     var numOfRow = 0;\n//     var numOfJson = 0;\n//     csv({fork:true}, { highWaterMark: 100 })\n//       .fromStream(rs)\n//       .subscribe(function (res, idx) {\n//         numOfJson++;\n//         assert.equal(res.Date, '8/26/16');\n//         assert(idx >= 0);\n//       })\n//       .on(\"done\", function () {\n//         assert(numOfJson === 1);\n//         done();\n//       });\n//   });\n//   it(\"should parse #139\", function (done) {\n//     var rs = fs.createReadStream(__dirname + \"/data/data#139\");\n//     csv({fork:true})\n//       .fromStream(rs)\n//       .then(function (res) {\n//         assert.equal(res[1].field3, \"9001009395 9001009990\");\n//         done();\n//       });\n//   });\n\n//   it(\"should ignore column\", function (done) {\n//     var rs = fs.createReadStream(__dirname + \"/data/dataWithQoutes\");\n//     var headerEmitted = false;\n//     csv({\n//       ignoreColumns: /TIMESTAMP/,\n//       fork:true\n//     })\n//       .fromStream(rs)\n//       .on(\"header\", function (header) {\n//         assert.equal(header.indexOf(\"TIMESTAMP\"), -1);\n//         assert.equal(header.indexOf(\"UPDATE\"), 0);\n//         if (headerEmitted) {\n//           throw (\"header event should only happen once\")\n//         }\n//         headerEmitted = true;\n//       })\n//       // .on(\"csv\", function (row, idx) {\n//       //   if (!headerEmitted) {\n//       //     throw (\"header should be emitted before any data events\");\n//       //   }\n//       //   assert(idx >= 0);\n//       //   if (idx === 1) {\n//       //     assert.equal(row[0], \"n\");\n//       //   }\n//       // })\n//       .subscribe(function (j, idx) {\n//         // console.log(j);\n//         assert(!j.TIMESTAMP);\n//         assert(idx >= 0);\n//       })\n//       .on(\"done\", function (err) {\n//         assert(!err);\n//         assert(headerEmitted);\n//         done();\n//       });\n//   });\n//   it(\"should include column\", function (done) {\n//     var rs = fs.createReadStream(__dirname + \"/data/dataWithQoutes\");\n//     csv({\n//       includeColumns: /TIMESTAMP/,\n//       fork:true\n//     })\n//       .fromStream(rs)\n//       .on(\"header\", function (header) {\n//         assert.equal(header.indexOf(\"TIMESTAMP\"), 0);\n//         assert.equal(header.indexOf(\"UPDATE\"), -1);\n//         assert.equal(header.length, 1);\n//       })\n//       .subscribe(function (j, idx) {\n//         assert(idx >= 0);\n//         if (idx === 1) {\n//           assert.equal(j.TIMESTAMP, \"abc, def, ccc\");\n//         }\n//         assert(!j.UID)\n//         assert(!j['BYTES SENT'])\n//       })\n//       .on(\"done\", function () {\n//         done();\n//       });\n//   });\n//   it(\"should allow headers and include columns to be given as reference to the same var\", function (done) {\n//     var rs = fs.createReadStream(__dirname + \"/data/complexJSONCSV\");\n//     var headers = [\n//       'first',\n//       'second',\n//       'third',\n//     ];\n\n//     var expected = headers;\n\n//     csv({\n//       headers: headers,\n//       includeColumns: /(first|second|third)/,\n//       fork:true\n//     })\n//       .fromStream(rs)\n//       .on(\"header\", function (header) {\n//         expected.forEach(function (value, index) {\n//           assert.equal(header.indexOf(value), index);\n//         });\n//       })\n//       .subscribe(function (j, idx) {\n//         assert(idx >= 0);\n//         assert.equal(expected.length, Object.keys(j).length);\n//         expected.forEach(function (attribute) {\n//           assert(j.hasOwnProperty(attribute));\n//         });\n//       })\n//       .on(\"done\", function () {\n//         done();\n//       });\n//   });\n\n//   it(\"should leave provided params objects unmutated\", function() {\n//     var rs = fs.createReadStream(__dirname + \"/data/complexJSONCSV\");\n//     var includeColumns = [\n//       'fieldA.title',\n//       'description',\n//     ];\n\n\n//     return csv({\n//       includeColumns: /(fieldA\\.title|description)/,\n//       fork:true\n//     })\n//       .fromStream(rs)\n//       .on(\"json\", function(j, idx) {\n//         assert(idx >= 0);\n//       })\n//       .on(\"header\", function(header) {\n//         includeColumns.forEach(function (value, index) {\n//           assert.equal(index, header.indexOf(value));\n//         });\n//       })\n//   });\n//   it(\"should accept pipe as quote\", function (done) {\n//     csv({\n//       quote: \"|\",\n//       output: \"csv\",\n//       \"fork\":true\n//     })\n//       .fromFile(__dirname + \"/data/pipeAsQuote\")\n//       .subscribe(function (csv) {\n//         assert.equal(csv[2], \"blahhh, blah\");\n//       })\n//       .on('done', function () {\n//         done()\n//       });\n//   })\n//   it(\"should allow async subscribe function\", () => {\n//     return csv({ trim: true,fork:true })\n//       .fromString(`a,b,c\n//     1,2,3\n//     4,5,6`)\n//       .subscribe((d) => {\n//         return new Promise((resolve, reject) => {\n//           setTimeout(() => {\n//             d.a = 10;\n//             resolve();\n//           }, 20);\n//         })\n//       })\n//       .then((d) => {\n//         assert.equal(d[0].a, 10);\n//         assert.equal(d[1].a, 10);\n//       })\n//   })\n//   it(\"should omit a column\", () => {\n//     return csv({\n//       colParser: {\n//         \"a\": \"omit\"\n//       },\n//       fork:true\n//     })\n//       .fromString(`a,b,c\n//   1,2,3\n//   fefe,5,6`)\n//       .then((d) => {\n//         assert.strictEqual(d[0].a, undefined);\n//         assert.equal(d[1].a, undefined);\n//       })\n//   })\n  \n// });\n"]}

.ts-node/4c960549d...af68e9e74f24d69965986f1dfd58764d8f18.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getEol_1 = __importDefault(require("./getEol"));
+var util_1 = require("./util");
+var defaulDelimiters = [",", "|", "\t", ";", ":"];
+var RowSplit = /** @class */ (function () {
+    function RowSplit(conv) {
+        this.conv = conv;
+        this.cachedRegExp = {};
+        this.delimiterEmitted = false;
+        this._needEmitDelimiter = undefined;
+        this.quote = conv.parseParam.quote;
+        this.trim = conv.parseParam.trim;
+        this.escape = conv.parseParam.escape;
+    }
+    Object.defineProperty(RowSplit.prototype, "needEmitDelimiter", {
+        get: function () {
+            if (this._needEmitDelimiter === undefined) {
+                this._needEmitDelimiter = this.conv.listeners("delimiter").length > 0;
+            }
+            return this._needEmitDelimiter;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RowSplit.prototype.parse = function (fileline) {
+        if (fileline.length === 0 || (this.conv.parseParam.ignoreEmpty && fileline.trim().length === 0)) {
+            return { cells: [], closed: true };
+        }
+        var quote = this.quote;
+        var trim = this.trim;
+        var escape = this.escape;
+        if (this.conv.parseRuntime.delimiter instanceof Array || this.conv.parseRuntime.delimiter.toLowerCase() === "auto") {
+            this.conv.parseRuntime.delimiter = this.getDelimiter(fileline);
+        }
+        if (this.needEmitDelimiter && !this.delimiterEmitted) {
+            this.conv.emit("delimiter", this.conv.parseRuntime.delimiter);
+            this.delimiterEmitted = true;
+        }
+        var delimiter = this.conv.parseRuntime.delimiter;
+        var rowArr = fileline.split(delimiter);
+        if (quote === "off") {
+            if (trim) {
+                for (var i = 0; i < rowArr.length; i++) {
+                    rowArr[i] = rowArr[i].trim();
+                }
+            }
+            return { cells: rowArr, closed: true };
+        }
+        else {
+            return this.toCSVRow(rowArr, trim, quote, delimiter);
+        }
+    };
+    RowSplit.prototype.toCSVRow = function (rowArr, trim, quote, delimiter) {
+        var row = [];
+        var inquote = false;
+        var quoteBuff = '';
+        for (var i = 0, rowLen = rowArr.length; i < rowLen; i++) {
+            var e = rowArr[i];
+            if (!inquote && trim) {
+                e = util_1.trimLeft(e);
+            }
+            var len = e.length;
+            if (!inquote) {
+                if (len === 2 && e === this.quote + this.quote) {
+                    row.push("");
+                    continue;
+                }
+                else if (this.isQuoteOpen(e)) { //quote open
+                    e = e.substr(1);
+                    if (this.isQuoteClose(e)) { //quote close
+                        e = e.substring(0, e.lastIndexOf(quote));
+                        e = this.escapeQuote(e);
+                        row.push(e);
+                        continue;
+                    }
+                    else if (e.indexOf(quote) !== -1) {
+                        var count = 0;
+                        for (var _i = 0, e_1 = e; _i < e_1.length; _i++) {
+                            var c = e_1[_i];
+                            if (c === quote) {
+                                count++;
+                            }
+                        }
+                        if (count % 2 === 1) {
+                            if (trim) {
+                                e = util_1.trimRight(e);
+                            }
+                            row.push(quote + e);
+                            continue;
+                        }
+                        else {
+                            inquote = true;
+                            quoteBuff += e;
+                            continue;
+                        }
+                    }
+                    else {
+                        inquote = true;
+                        quoteBuff += e;
+                        continue;
+                    }
+                }
+                else {
+                    if (trim) {
+                        e = util_1.trimRight(e);
+                    }
+                    row.push(e);
+                    continue;
+                }
+            }
+            else { //previous quote not closed
+                if (this.isQuoteClose(e)) { //close double quote
+                    inquote = false;
+                    e = e.substr(0, len - 1);
+                    quoteBuff += delimiter + e;
+                    quoteBuff = this.escapeQuote(quoteBuff);
+                    if (trim) {
+                        quoteBuff = util_1.trimRight(quoteBuff);
+                    }
+                    row.push(quoteBuff);
+                    quoteBuff = "";
+                }
+                else {
+                    quoteBuff += delimiter + e;
+                }
+            }
+        }
+        // if (!inquote && param._needFilterRow) {
+        //   row = filterRow(row, param);
+        // }
+        return { cells: row, closed: !inquote };
+    };
+    RowSplit.prototype.getDelimiter = function (fileline) {
+        var checker;
+        if (this.conv.parseParam.delimiter === "auto") {
+            checker = defaulDelimiters;
+        }
+        else if (this.conv.parseParam.delimiter instanceof Array) {
+            checker = this.conv.parseParam.delimiter;
+        }
+        else {
+            return this.conv.parseParam.delimiter;
+        }
+        var count = 0;
+        var rtn = ",";
+        checker.forEach(function (delim) {
+            var delimCount = fileline.split(delim).length;
+            if (delimCount > count) {
+                rtn = delim;
+                count = delimCount;
+            }
+        });
+        return rtn;
+    };
+    RowSplit.prototype.isQuoteOpen = function (str) {
+        var quote = this.quote;
+        var escape = this.escape;
+        return str[0] === quote && (str[1] !== quote ||
+            str[1] === escape && (str[2] === quote || str.length === 2));
+    };
+    RowSplit.prototype.isQuoteClose = function (str) {
+        var quote = this.quote;
+        var escape = this.escape;
+        if (this.conv.parseParam.trim) {
+            str = util_1.trimRight(str);
+        }
+        var count = 0;
+        var idx = str.length - 1;
+        while (str[idx] === quote || str[idx] === escape) {
+            idx--;
+            count++;
+        }
+        return count % 2 !== 0;
+    };
+    // private twoDoubleQuote(str: string): string {
+    //   var twoQuote = this.quote + this.quote;
+    //   var curIndex = -1;
+    //   while ((curIndex = str.indexOf(twoQuote, curIndex)) > -1) {
+    //     str = str.substring(0, curIndex) + str.substring(++curIndex);
+    //   }
+    //   return str;
+    // }
+    RowSplit.prototype.escapeQuote = function (segment) {
+        var key = "es|" + this.quote + "|" + this.escape;
+        if (this.cachedRegExp[key] === undefined) {
+            this.cachedRegExp[key] = new RegExp('\\' + this.escape + '\\' + this.quote, 'g');
+        }
+        var regExp = this.cachedRegExp[key];
+        // console.log(regExp,segment);
+        return segment.replace(regExp, this.quote);
+    };
+    RowSplit.prototype.parseMultiLines = function (lines) {
+        var csvLines = [];
+        var left = "";
+        while (lines.length) {
+            var line = left + lines.shift();
+            var row = this.parse(line);
+            if (row.cells.length === 0 && this.conv.parseParam.ignoreEmpty) {
+                continue;
+            }
+            if (row.closed || this.conv.parseParam.alwaysSplitAtEOL) {
+                if (this.conv.parseRuntime.selectedColumns) {
+                    csvLines.push(util_1.filterArray(row.cells, this.conv.parseRuntime.selectedColumns));
+                }
+                else {
+                    csvLines.push(row.cells);
+                }
+                left = "";
+            }
+            else {
+                left = line + (getEol_1.default(line, this.conv.parseRuntime) || "\n");
+            }
+        }
+        return { rowsCells: csvLines, partial: left };
+    };
+    return RowSplit;
+}());
+exports.RowSplit = RowSplit;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/rowSplit.ts","sources":["/Users/kxiang/work/projects/csv2json/src/rowSplit.ts"],"names":[],"mappings":"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","sourcesContent":["import { CSVParseParam } from \"./Parameters\";\nimport { Converter } from \"./Converter\";\nimport { Fileline } from \"./fileline\";\nimport getEol from \"./getEol\";\nimport { filterArray, trimLeft, trimRight } from \"./util\";\n\nconst defaulDelimiters = [\",\", \"|\", \"\\t\", \";\", \":\"];\nexport class RowSplit {\n  private quote: string;\n  private trim: boolean;\n  private escape: string;\n  private cachedRegExp: { [key: string]: RegExp } = {};\n  private delimiterEmitted = false;\n  private _needEmitDelimiter?: boolean = undefined;\n  private get needEmitDelimiter() {\n    if (this._needEmitDelimiter === undefined) {\n      this._needEmitDelimiter = this.conv.listeners(\"delimiter\").length > 0;\n    }\n    return this._needEmitDelimiter;\n  }\n  constructor(private conv: Converter) {\n    this.quote = conv.parseParam.quote;\n    this.trim = conv.parseParam.trim;\n    this.escape = conv.parseParam.escape;\n  }\n  parse(fileline: Fileline): RowSplitResult {\n    if (fileline.length === 0 || (this.conv.parseParam.ignoreEmpty && fileline.trim().length === 0)) {\n      return { cells: [], closed: true };\n    }\n    const quote = this.quote;\n    const trim = this.trim;\n    const escape = this.escape;\n    if (this.conv.parseRuntime.delimiter instanceof Array || this.conv.parseRuntime.delimiter.toLowerCase() === \"auto\") {\n      this.conv.parseRuntime.delimiter = this.getDelimiter(fileline);\n\n    }\n    if (this.needEmitDelimiter && !this.delimiterEmitted) {\n      this.conv.emit(\"delimiter\", this.conv.parseRuntime.delimiter);\n      this.delimiterEmitted = true;\n    }\n    const delimiter = this.conv.parseRuntime.delimiter;\n    const rowArr = fileline.split(delimiter);\n    if (quote === \"off\") {\n      if (trim) {\n        for (let i = 0; i < rowArr.length; i++) {\n          rowArr[i] = rowArr[i].trim();\n        }\n      }\n      return { cells: rowArr, closed: true };\n    } else {\n      return this.toCSVRow(rowArr, trim, quote, delimiter);\n    }\n\n  }\n  private toCSVRow(rowArr: string[], trim: boolean, quote: string, delimiter: string): RowSplitResult {\n    const row: string[] = [];\n    let inquote = false;\n    let quoteBuff = '';\n    for (let i = 0, rowLen = rowArr.length; i < rowLen; i++) {\n      let e = rowArr[i];\n      if (!inquote && trim) {\n        e = trimLeft(e);\n      }\n      const len = e.length;\n      if (!inquote) {\n        if (len === 2 && e === this.quote + this.quote) {\n          row.push(\"\");\n          continue;\n        } else if (this.isQuoteOpen(e)) { //quote open\n          e = e.substr(1);\n          if (this.isQuoteClose(e)) { //quote close\n            e = e.substring(0, e.lastIndexOf(quote));\n            e = this.escapeQuote(e);\n            row.push(e);\n            continue;\n          } else if (e.indexOf(quote) !== -1) {\n            let count = 0;\n            for (const c of e) {\n              if (c === quote) {\n                count++;\n              }\n            }\n            if (count % 2 === 1) {\n              if (trim) {\n                e = trimRight(e);\n              }\n              row.push(quote + e);\n              continue;\n            }else{\n              inquote = true;\n              quoteBuff += e;\n              continue;  \n            }\n          }\n          else {\n            inquote = true;\n            quoteBuff += e;\n            continue;\n          }\n        } else {\n          if (trim) {\n            e = trimRight(e);\n          }\n          row.push(e);\n          continue;\n        }\n      } else { //previous quote not closed\n        if (this.isQuoteClose(e)) { //close double quote\n          inquote = false;\n          e = e.substr(0, len - 1);\n          quoteBuff += delimiter + e;\n          quoteBuff = this.escapeQuote(quoteBuff);\n          if (trim) {\n            quoteBuff = trimRight(quoteBuff);\n          }\n          row.push(quoteBuff);\n          quoteBuff = \"\";\n        } else {\n          quoteBuff += delimiter + e;\n        }\n      }\n    }\n\n    // if (!inquote && param._needFilterRow) {\n    //   row = filterRow(row, param);\n    // }\n\n    return { cells: row, closed: !inquote };\n  }\n  private getDelimiter(fileline: Fileline): string {\n    let checker;\n    if (this.conv.parseParam.delimiter === \"auto\") {\n      checker = defaulDelimiters;\n    } else if (this.conv.parseParam.delimiter instanceof Array) {\n      checker = this.conv.parseParam.delimiter;\n    } else {\n      return this.conv.parseParam.delimiter;\n    }\n    let count = 0;\n    let rtn = \",\";\n    checker.forEach(function (delim) {\n      const delimCount = fileline.split(delim).length;\n      if (delimCount > count) {\n        rtn = delim;\n        count = delimCount;\n      }\n    });\n    return rtn;\n  }\n  private isQuoteOpen(str: string): boolean {\n    const quote = this.quote;\n    const escape = this.escape;\n    return str[0] === quote && (\n      str[1] !== quote ||\n      str[1] === escape && (str[2] === quote || str.length === 2));\n  }\n  private isQuoteClose(str: string): boolean {\n    const quote = this.quote;\n    const escape = this.escape;\n    if (this.conv.parseParam.trim) {\n      str = trimRight(str);\n    }\n    let count = 0;\n    let idx = str.length - 1;\n    while (str[idx] === quote || str[idx] === escape) {\n      idx--;\n      count++;\n    }\n    return count % 2 !== 0;\n  }\n\n  // private twoDoubleQuote(str: string): string {\n  //   var twoQuote = this.quote + this.quote;\n  //   var curIndex = -1;\n  //   while ((curIndex = str.indexOf(twoQuote, curIndex)) > -1) {\n  //     str = str.substring(0, curIndex) + str.substring(++curIndex);\n  //   }\n  //   return str;\n  // }\n\n\n  private escapeQuote(segment: string): string {\n    const key = \"es|\" + this.quote + \"|\" + this.escape;\n    if (this.cachedRegExp[key] === undefined) {\n      this.cachedRegExp[key] = new RegExp('\\\\' + this.escape + '\\\\' + this.quote, 'g');\n    }\n    const regExp = this.cachedRegExp[key];\n    // console.log(regExp,segment);\n    return segment.replace(regExp, this.quote);\n  }\n  parseMultiLines(lines: Fileline[]): MultipleRowResult {\n    const csvLines: string[][] = [];\n    let left = \"\";\n    while (lines.length) {\n      const line = left + lines.shift();\n      const row = this.parse(line);\n      if (row.cells.length === 0 && this.conv.parseParam.ignoreEmpty) {\n        continue;\n      }\n      if (row.closed || this.conv.parseParam.alwaysSplitAtEOL) {\n        if (this.conv.parseRuntime.selectedColumns) {\n          csvLines.push(filterArray(row.cells, this.conv.parseRuntime.selectedColumns));\n        } else {\n          csvLines.push(row.cells);\n        }\n\n        left = \"\";\n      } else {\n        left = line + (getEol(line, this.conv.parseRuntime) || \"\\n\");\n      }\n    }\n    return { rowsCells: csvLines, partial: left };\n  }\n}\nexport interface MultipleRowResult {\n  rowsCells: string[][];\n  partial: string;\n}\nexport interface RowSplitResult {\n  /**\n   * csv row array. [\"a\",\"b\",\"c\"]\n   */\n  cells: string[],\n  /**\n   * if the passed fileline is a complete row\n   */\n  closed: boolean\n}\n\n"]}

.ts-node/4c960549d...264b6721c20a7144d863993a743b0fd3d45f.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var bluebird_1 = __importDefault(require("bluebird"));
+var os_1 = require("os");
+var Result = /** @class */ (function () {
+    function Result(converter) {
+        this.converter = converter;
+        this.finalResult = [];
+    }
+    Object.defineProperty(Result.prototype, "needEmitLine", {
+        get: function () {
+            return !!this.converter.parseRuntime.subscribe && !!this.converter.parseRuntime.subscribe.onNext || this.needPushDownstream;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Result.prototype, "needPushDownstream", {
+        get: function () {
+            if (this._needPushDownstream === undefined) {
+                this._needPushDownstream = this.converter.listeners("data").length > 0 || this.converter.listeners("readable").length > 0;
+            }
+            return this._needPushDownstream;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Result.prototype, "needEmitAll", {
+        get: function () {
+            return !!this.converter.parseRuntime.then && this.converter.parseParam.needEmitAll;
+            // return !!this.converter.parseRuntime.then;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Result.prototype.processResult = function (resultLines) {
+        var _this = this;
+        var startPos = this.converter.parseRuntime.parsedLineNumber;
+        if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === "array") {
+            if (startPos === 0) {
+                pushDownstream(this.converter, "[" + os_1.EOL);
+            }
+        }
+        // let prom: P<any>;
+        return new bluebird_1.default(function (resolve, reject) {
+            if (_this.needEmitLine) {
+                processLineByLine(resultLines, _this.converter, 0, _this.needPushDownstream, function (err) {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        _this.appendFinalResult(resultLines);
+                        resolve();
+                    }
+                });
+                // resolve();
+            }
+            else {
+                _this.appendFinalResult(resultLines);
+                resolve();
+            }
+        });
+    };
+    Result.prototype.appendFinalResult = function (lines) {
+        if (this.needEmitAll) {
+            this.finalResult = this.finalResult.concat(lines);
+        }
+        this.converter.parseRuntime.parsedLineNumber += lines.length;
+    };
+    Result.prototype.processError = function (err) {
+        if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onError) {
+            this.converter.parseRuntime.subscribe.onError(err);
+        }
+        if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onrejected) {
+            this.converter.parseRuntime.then.onrejected(err);
+        }
+    };
+    Result.prototype.endProcess = function () {
+        if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onfulfilled) {
+            if (this.needEmitAll) {
+                this.converter.parseRuntime.then.onfulfilled(this.finalResult);
+            }
+            else {
+                this.converter.parseRuntime.then.onfulfilled([]);
+            }
+        }
+        if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onCompleted) {
+            this.converter.parseRuntime.subscribe.onCompleted();
+        }
+        if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === "array") {
+            pushDownstream(this.converter, "]" + os_1.EOL);
+        }
+    };
+    return Result;
+}());
+exports.Result = Result;
+function processLineByLine(lines, conv, offset, needPushDownstream, cb) {
+    if (offset >= lines.length) {
+        cb();
+    }
+    else {
+        if (conv.parseRuntime.subscribe && conv.parseRuntime.subscribe.onNext) {
+            var hook_1 = conv.parseRuntime.subscribe.onNext;
+            var nextLine_1 = lines[offset];
+            var res = hook_1(nextLine_1, conv.parseRuntime.parsedLineNumber + offset);
+            offset++;
+            // if (isAsync === undefined) {
+            if (res && res.then) {
+                res.then(function () {
+                    processRecursive(lines, hook_1, conv, offset, needPushDownstream, cb, nextLine_1);
+                }, cb);
+            }
+            else {
+                // processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);
+                if (needPushDownstream) {
+                    pushDownstream(conv, nextLine_1);
+                }
+                while (offset < lines.length) {
+                    var line = lines[offset];
+                    hook_1(line, conv.parseRuntime.parsedLineNumber + offset);
+                    offset++;
+                    if (needPushDownstream) {
+                        pushDownstream(conv, line);
+                    }
+                }
+                cb();
+            }
+            // } else if (isAsync === true) {
+            //   (res as PromiseLike<void>).then(function () {
+            //     processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, true);
+            //   }, cb);
+            // } else if (isAsync === false) {
+            //   processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);
+            // }
+        }
+        else {
+            if (needPushDownstream) {
+                while (offset < lines.length) {
+                    var line = lines[offset++];
+                    pushDownstream(conv, line);
+                }
+            }
+            cb();
+        }
+    }
+}
+function processRecursive(lines, hook, conv, offset, needPushDownstream, cb, res) {
+    if (needPushDownstream) {
+        pushDownstream(conv, res);
+    }
+    processLineByLine(lines, conv, offset, needPushDownstream, cb);
+}
+function pushDownstream(conv, res) {
+    if (typeof res === "object" && !conv.options.objectMode) {
+        var data = JSON.stringify(res);
+        conv.push(data + (conv.parseParam.downstreamFormat === "array" ? "," + os_1.EOL : os_1.EOL), "utf8");
+    }
+    else {
+        conv.push(res);
+    }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/Result.ts","sources":["/Users/kxiang/work/projects/csv2json/src/Result.ts"],"names":[],"mappings":"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","sourcesContent":["import { Converter } from \"./Converter\";\nimport { ProcessLineResult } from \"./Processor\";\nimport P from \"bluebird\";\nimport CSVError from \"./CSVError\";\nimport { EOL } from \"os\";\nexport class Result {\n  private get needEmitLine(): boolean {\n    return !!this.converter.parseRuntime.subscribe && !!this.converter.parseRuntime.subscribe.onNext || this.needPushDownstream\n  }\n  private _needPushDownstream?: boolean;\n  private get needPushDownstream(): boolean {\n    if (this._needPushDownstream === undefined) {\n      this._needPushDownstream = this.converter.listeners(\"data\").length > 0 || this.converter.listeners(\"readable\").length > 0;\n    }\n    return this._needPushDownstream;\n  }\n  private get needEmitAll(): boolean {\n    return !!this.converter.parseRuntime.then && this.converter.parseParam.needEmitAll;\n    // return !!this.converter.parseRuntime.then;\n  }\n  private finalResult: any[] = [];\n  constructor(private converter: Converter) { }\n  processResult(resultLines: ProcessLineResult[]): P<any> {\n    const startPos = this.converter.parseRuntime.parsedLineNumber;\n    if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === \"array\") {\n      if (startPos === 0) {\n        pushDownstream(this.converter, \"[\" + EOL);\n      }\n    }\n    // let prom: P<any>;\n    return new P((resolve, reject) => {\n      if (this.needEmitLine) {\n        processLineByLine(\n          resultLines,\n          this.converter,\n          0,\n          this.needPushDownstream,\n          (err) => {\n            if (err) {\n              reject(err);\n            } else {\n              this.appendFinalResult(resultLines);\n              resolve();\n            }\n          },\n        )\n        // resolve();\n      } else {\n        this.appendFinalResult(resultLines);\n        resolve();\n      }\n    })\n  }\n  appendFinalResult(lines: any[]) {\n    if (this.needEmitAll) {\n      this.finalResult = this.finalResult.concat(lines);\n    }\n    this.converter.parseRuntime.parsedLineNumber += lines.length;\n  }\n  processError(err: CSVError) {\n    if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onError) {\n      this.converter.parseRuntime.subscribe.onError(err);\n    }\n    if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onrejected) {\n      this.converter.parseRuntime.then.onrejected(err);\n    }\n  }\n  endProcess() {\n    \n      if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onfulfilled) {\n        if (this.needEmitAll) {\n          this.converter.parseRuntime.then.onfulfilled(this.finalResult);\n        }else{\n          this.converter.parseRuntime.then.onfulfilled([]);\n        }\n      }\n    if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onCompleted) {\n      this.converter.parseRuntime.subscribe.onCompleted();\n    }\n    if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === \"array\") {\n      pushDownstream(this.converter, \"]\" + EOL);\n    }\n  }\n}\n\nfunction processLineByLine(\n  lines: ProcessLineResult[],\n\n  conv: Converter,\n  offset: number,\n  needPushDownstream: boolean,\n  cb: (err?) => void,\n) {\n  if (offset >= lines.length) {\n    cb();\n  } else {\n    if (conv.parseRuntime.subscribe && conv.parseRuntime.subscribe.onNext) {\n      const hook = conv.parseRuntime.subscribe.onNext;\n      const nextLine = lines[offset];\n      const res = hook(nextLine, conv.parseRuntime.parsedLineNumber + offset);\n      offset++;\n      // if (isAsync === undefined) {\n      if (res && res.then) {\n        res.then(function () {\n          processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine);\n        }, cb);\n      } else {\n        // processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);\n        if (needPushDownstream) {\n          pushDownstream(conv, nextLine);\n        }\n        while (offset < lines.length) {\n          const line = lines[offset];\n          hook(line, conv.parseRuntime.parsedLineNumber + offset);\n          offset++;\n          if (needPushDownstream) {\n            pushDownstream(conv, line);\n          }\n        }\n        cb();\n      }\n      // } else if (isAsync === true) {\n      //   (res as PromiseLike<void>).then(function () {\n      //     processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, true);\n      //   }, cb);\n      // } else if (isAsync === false) {\n      //   processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);\n      // }\n    } else {\n      if (needPushDownstream) {\n        while (offset < lines.length) {\n          const line = lines[offset++];\n          pushDownstream(conv, line);\n        }\n\n      }\n      cb();\n    }\n\n  }\n}\n\nfunction processRecursive(\n  lines: ProcessLineResult[],\n  hook: (data: any, lineNumber: number) => void | PromiseLike<void>,\n  conv: Converter,\n  offset: number,\n  needPushDownstream: boolean,\n  cb: (err?) => void,\n  res: ProcessLineResult,\n) {\n  if (needPushDownstream) {\n    pushDownstream(conv, res);\n  }\n  processLineByLine(lines, conv, offset, needPushDownstream, cb);\n}\nfunction pushDownstream(conv: Converter, res: ProcessLineResult) {\n  if (typeof res === \"object\" && !conv.options.objectMode) {\n    const data = JSON.stringify(res);\n    conv.push(data + (conv.parseParam.downstreamFormat === \"array\" ? \",\" + EOL : EOL), \"utf8\");\n  } else {\n    conv.push(res);\n  }\n}"]}

.ts-node/4c960549d...03a456f7a02682d837efbfd48c3882c1725a.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var strip_bom_1 = __importDefault(require("strip-bom"));
+/**
+ * For each data chunk coming to parser:
+ * 1. append the data to the buffer that is left from last chunk
+ * 2. check if utf8 chars being split, if does, stripe the bytes and add to left buffer.
+ * 3. stripBom
+ */
+function prepareData(chunk, runtime) {
+    var workChunk = concatLeftChunk(chunk, runtime);
+    runtime.csvLineBuffer = undefined;
+    var cleanCSVString = cleanUtf8Split(workChunk, runtime).toString("utf8");
+    if (runtime.started === false) {
+        return strip_bom_1.default(cleanCSVString);
+    }
+    else {
+        return cleanCSVString;
+    }
+}
+exports.prepareData = prepareData;
+/**
+ *  append data to buffer that is left form last chunk
+ */
+function concatLeftChunk(chunk, runtime) {
+    if (runtime.csvLineBuffer && runtime.csvLineBuffer.length > 0) {
+        return Buffer.concat([runtime.csvLineBuffer, chunk]);
+    }
+    else {
+        return chunk;
+    }
+}
+/**
+ * check if utf8 chars being split, if does, stripe the bytes and add to left buffer.
+ */
+function cleanUtf8Split(chunk, runtime) {
+    var idx = chunk.length - 1;
+    /**
+     * From Keyang:
+     * The code below is to check if a single utf8 char (which could be multiple bytes) being split.
+     * If the char being split, the buffer from two chunk needs to be concat
+     * check how utf8 being encoded to understand the code below.
+     * If anyone has any better way to do this, please let me know.
+     */
+    if ((chunk[idx] & 1 << 7) != 0) {
+        while ((chunk[idx] & 3 << 6) === 128) {
+            idx--;
+        }
+        idx--;
+    }
+    if (idx != chunk.length - 1) {
+        runtime.csvLineBuffer = chunk.slice(idx + 1);
+        return chunk.slice(0, idx + 1);
+        // var _cb=cb;
+        // var self=this;
+        // cb=function(){
+        //   if (self._csvLineBuffer){
+        //     self._csvLineBuffer=Buffer.concat([bufFromString(self._csvLineBuffer,"utf8"),left]);
+        //   }else{
+        //     self._csvLineBuffer=left;
+        //   }
+        //   _cb();
+        // }
+    }
+    else {
+        return chunk;
+    }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/4c960549d...ed78373de3210b31ccf65b4aed7731f9e9cd.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Converter_1 = require("../src/Converter");
+var src_1 = __importDefault(require("../src"));
+var assert = require("assert");
+var fs = require("fs");
+var sandbox = require("sinon").sandbox.create();
+var file = __dirname + "/data/testData";
+var trailCommaData = __dirname + "/data/trailingComma";
+describe("CSV Converter", function () {
+    afterEach(function () {
+        sandbox.restore();
+    });
+    it("should create new instance of csv", function () {
+        var obj = new Converter_1.Converter();
+        assert(obj);
+    });
+    it("should read from a stream", function (done) {
+        var obj = new Converter_1.Converter();
+        var stream = fs.createReadStream(file);
+        obj.then(function (obj) {
+            assert.equal(obj.length, 2);
+            done();
+        });
+        stream.pipe(obj);
+    });
+    it("should call onNext once a row is parsed.", function (done) {
+        var obj = new Converter_1.Converter();
+        var stream = fs.createReadStream(file);
+        var called = false;
+        obj.subscribe(function (resultRow) {
+            assert(resultRow);
+            called = true;
+        });
+        obj.on("done", function () {
+            assert(called);
+            done();
+        });
+        stream.pipe(obj);
+    });
+    it("should emit end_parsed message once it is finished.", function (done) {
+        var obj = new Converter_1.Converter();
+        obj.then(function (result) {
+            assert(result);
+            assert(result.length === 2);
+            assert(result[0].date);
+            assert(result[0].employee);
+            assert(result[0].employee.name);
+            assert(result[0].employee.age);
+            assert(result[0].employee.number);
+            assert(result[0].employee.key.length === 2);
+            assert(result[0].address.length === 2);
+            done();
+        });
+        fs.createReadStream(file).pipe(obj);
+    });
+    it("should handle traling comma gracefully", function (done) {
+        var stream = fs.createReadStream(trailCommaData);
+        var obj = new Converter_1.Converter();
+        obj.then(function (result) {
+            assert(result);
+            assert(result.length > 0);
+            done();
+        });
+        stream.pipe(obj);
+    });
+    it("should handle comma in column which is surrounded by qoutes", function (done) {
+        var testData = __dirname + "/data/dataWithComma";
+        var rs = fs.createReadStream(testData);
+        var obj = new Converter_1.Converter({
+            "quote": "#"
+        });
+        obj.then(function (result) {
+            assert(result[0].col1 === "\"Mini. Sectt");
+            assert.equal(result[3].col2, "125001,fenvkdsf");
+            // console.log(result);
+            done();
+        });
+        rs.pipe(obj);
+    });
+    it("should be able to convert a csv to column array data", function (done) {
+        var columArrData = __dirname + "/data/columnArray";
+        var rs = fs.createReadStream(columArrData);
+        var result = {};
+        var csvConverter = new Converter_1.Converter();
+        //end_parsed will be emitted once parsing finished
+        csvConverter.then(function () {
+            assert(result.TIMESTAMP.length === 5);
+            done();
+        });
+        //record_parsed will be emitted each time a row has been parsed.
+        csvConverter.subscribe(function (resultRow, rowIndex) {
+            for (var key in resultRow) {
+                if (resultRow.hasOwnProperty(key)) {
+                    if (!result[key] || !(result[key] instanceof Array)) {
+                        result[key] = [];
+                    }
+                    result[key][rowIndex] = resultRow[key];
+                }
+            }
+        });
+        rs.pipe(csvConverter);
+    });
+    it("should be able to convert csv string directly", function (done) {
+        var testData = __dirname + "/data/testData";
+        var data = fs.readFileSync(testData).toString();
+        var csvConverter = new Converter_1.Converter();
+        //end_parsed will be emitted once parsing finished
+        csvConverter.then(function (jsonObj) {
+            assert.equal(jsonObj.length, 2);
+        });
+        csvConverter.fromString(data).then(function (jsonObj) {
+            assert(jsonObj.length === 2);
+            done();
+        });
+    });
+    it("should be able to convert csv string with error", function (done) {
+        var testData = __dirname + "/data/dataWithUnclosedQuotes";
+        var data = fs.readFileSync(testData).toString();
+        var csvConverter = new Converter_1.Converter();
+        csvConverter.fromString(data).then(undefined, function (err) {
+            assert(err);
+            assert.equal(err.err, "unclosed_quote");
+            done();
+        });
+    });
+    it("should be able to convert csv string without callback provided", function (done) {
+        var testData = __dirname + "/data/testData";
+        var data = fs.readFileSync(testData).toString();
+        var csvConverter = new Converter_1.Converter();
+        //end_parsed will be emitted once parsing finished
+        csvConverter.then(function (jsonObj) {
+            assert(jsonObj.length === 2);
+            done();
+        });
+        csvConverter.fromString(data);
+    });
+    it("should be able to handle columns with double quotes", function (done) {
+        var testData = __dirname + "/data/dataWithQoutes";
+        var data = fs.readFileSync(testData).toString();
+        var csvConverter = new Converter_1.Converter();
+        csvConverter.fromString(data).then(function (jsonObj) {
+            assert(jsonObj[0].TIMESTAMP === '13954264"22', JSON.stringify(jsonObj[0].TIMESTAMP));
+            assert(jsonObj[1].TIMESTAMP === 'abc, def, ccc', JSON.stringify(jsonObj[1].TIMESTAMP));
+            done();
+        });
+    });
+    it("should be able to handle columns with two double quotes", function (done) {
+        var testData = __dirname + "/data/twodoublequotes";
+        var data = fs.readFileSync(testData).toString();
+        var csvConverter = new Converter_1.Converter();
+        csvConverter.fromString(data).then(function (jsonObj) {
+            assert.equal(jsonObj[0].title, "\"");
+            assert.equal(jsonObj[0].data, "xyabcde");
+            assert.equal(jsonObj[0].uuid, "fejal\"eifa");
+            assert.equal(jsonObj[0].fieldA, "bnej\"\"falkfe");
+            assert.equal(jsonObj[0].fieldB, "\"eisjfes\"");
+            done();
+        });
+    });
+    it("should handle empty csv file", function (done) {
+        var testData = __dirname + "/data/emptyFile";
+        var rs = fs.createReadStream(testData);
+        var csvConverter = new Converter_1.Converter();
+        csvConverter.then(function (jsonObj) {
+            assert(jsonObj.length === 0);
+            done();
+        });
+        rs.pipe(csvConverter);
+    });
+    it("should parse large csv file", function (done) {
+        var testData = __dirname + "/data/large-csv-sample.csv";
+        var rs = fs.createReadStream(testData);
+        var csvConverter = new Converter_1.Converter();
+        var count = 0;
+        csvConverter.subscribe(function () {
+            //console.log(arguments);
+            count++;
+        });
+        csvConverter.then(function () {
+            assert(count === 5290);
+            done();
+        });
+        rs.pipe(csvConverter);
+    });
+    it("should parse data and covert to specific types", function (done) {
+        var testData = __dirname + "/data/dataWithType";
+        var rs = fs.createReadStream(testData);
+        var csvConverter = new Converter_1.Converter({
+            checkType: true,
+            colParser: {
+                "column6": "string",
+                "column7": "string"
+            }
+        });
+        csvConverter.subscribe(function (d) {
+            assert(typeof d.column1 === "number");
+            assert(typeof d.column2 === "string");
+            assert.equal(d["colume4"], "someinvaliddate");
+            assert(d.column5.hello === "world");
+            assert(d.column6 === '{"hello":"world"}');
+            assert(d.column7 === "1234");
+            assert(d.column8 === "abcd");
+            assert(d.column9 === true);
+            assert(d.column10[0] === 23);
+            assert(d.column10[1] === 31);
+            assert(d.column11[0].hello === "world");
+            assert(d["name#!"] === false);
+        });
+        csvConverter.on("done", function () {
+            done();
+        });
+        rs.pipe(csvConverter);
+    });
+    it("should turn off field type check", function (done) {
+        var testData = __dirname + "/data/dataWithType";
+        var rs = fs.createReadStream(testData);
+        var csvConverter = new Converter_1.Converter({
+            checkType: false
+        });
+        csvConverter.subscribe(function (d) {
+            assert(typeof d.column1 === "string");
+            assert(typeof d.column2 === "string");
+            assert(d["column3"] === "2012-01-01");
+            assert(d["colume4"] === "someinvaliddate");
+            assert(d.column5 === '{"hello":"world"}');
+            assert.equal(d["column6"], '{"hello":"world"}');
+            assert(d["column7"] === "1234");
+            assert(d["column8"] === "abcd");
+            assert(d.column9 === "true");
+            assert(d.column10[0] === "23");
+            assert(d.column10[1] === "31");
+            assert(d["name#!"] === 'false');
+        });
+        csvConverter.then(function () {
+            done();
+        });
+        rs.pipe(csvConverter);
+    });
+    it("should emit data event correctly", function (done) {
+        var testData = __dirname + "/data/large-csv-sample.csv";
+        var csvConverter = new Converter_1.Converter({});
+        var count = 0;
+        csvConverter.on("data", function (d) {
+            count++;
+        });
+        csvConverter.on("end", function () {
+            assert.equal(count, 5290);
+            done();
+        });
+        var rs = fs.createReadStream(testData);
+        rs.pipe(csvConverter);
+    });
+    it("should process column with linebreaks", function (done) {
+        var testData = __dirname + "/data/lineBreak";
+        var rs = fs.createReadStream(testData);
+        var csvConverter = new Converter_1.Converter({
+            checkType: true
+        });
+        csvConverter.subscribe(function (d) {
+            assert(d.Period === 13);
+            assert(d["Apparent age"] === "Unknown");
+            done();
+        });
+        rs.pipe(csvConverter);
+    });
+    it("be able to ignore empty columns", function (done) {
+        var testData = __dirname + "/data/dataIgnoreEmpty";
+        var rs = fs.createReadStream(testData);
+        var st = rs.pipe(src_1.default({ ignoreEmpty: true }));
+        st.then(function (res) {
+            var j = res[0];
+            assert(res.length === 3);
+            assert(j.col2.length === 2);
+            assert(j.col2[1] === "d3");
+            assert(j.col4.col3 === undefined);
+            assert(j.col4.col5 === "world");
+            assert(res[1].col1 === "d2");
+            assert(res[2].col1 === "d4");
+            done();
+        });
+    });
+    it("should allow no header", function (done) {
+        var testData = __dirname + "/data/noheadercsv";
+        var rs = fs.createReadStream(testData);
+        var st = rs.pipe(new Converter_1.Converter({ noheader: true }));
+        st.then(function (res) {
+            var j = res[0];
+            assert(res.length === 5);
+            assert(j.field1 === "CC102-PDMI-001");
+            assert(j.field2 === "eClass_5.1.3");
+            done();
+        });
+    });
+    it("should allow customised header", function (done) {
+        var testData = __dirname + "/data/noheadercsv";
+        var rs = fs.createReadStream(testData);
+        var st = rs.pipe(new Converter_1.Converter({
+            noheader: true,
+            headers: ["a", "b"]
+        }));
+        st.then(function (res) {
+            var j = res[0];
+            assert(res.length === 5);
+            assert(j.a === "CC102-PDMI-001");
+            assert(j.b === "eClass_5.1.3");
+            assert(j.field3 === "10/3/2014");
+            done();
+        });
+    });
+    it("should allow customised header to override existing header", function (done) {
+        var testData = __dirname + "/data/complexJSONCSV";
+        var rs = fs.createReadStream(testData);
+        var st = rs.pipe(new Converter_1.Converter({
+            headers: []
+        }));
+        st.then(function (res) {
+            var j = res[0];
+            assert(res.length === 2);
+            assert(j.field1 === "Food Factory");
+            assert(j.field2 === "Oscar");
+            done();
+        });
+    });
+    it("should handle when there is an empty string", function (done) {
+        var testData = __dirname + "/data/dataWithEmptyString";
+        var rs = fs.createReadStream(testData);
+        var st = rs.pipe(new Converter_1.Converter({
+            noheader: true,
+            headers: ["a", "b", "c"],
+            checkType: true
+        }));
+        st.then(function (res) {
+            var j = res[0];
+            // assert(res.length===2);
+            assert(j.a === "green");
+            assert(j.b === 40);
+            assert.equal(j.c, "");
+            done();
+        });
+    });
+    it("should detect eol correctly when first chunk is smaller than header row length", function (done) {
+        var testData = __dirname + "/data/dataNoTrimCRLF";
+        var rs = fs.createReadStream(testData, { highWaterMark: 3 });
+        var st = rs.pipe(new Converter_1.Converter({
+            trim: false
+        }));
+        st.then(function (res) {
+            var j = res[0];
+            assert(res.length === 2);
+            assert(j.name === "joe");
+            assert(j.age === "20");
+            assert.equal(res[1].name, "sam");
+            assert.equal(res[1].age, "30");
+            done();
+        });
+    });
+    it("should detect eol correctly when first chunk ends in middle of CRLF line break", function (done) {
+        var testData = __dirname + "/data/dataNoTrimCRLF";
+        var rs = fs.createReadStream(testData, { highWaterMark: 9 });
+        var st = rs.pipe(new Converter_1.Converter({
+            trim: false
+        }));
+        st.then(function (res) {
+            var j = res[0];
+            assert(res.length === 2);
+            assert(j.name === "joe");
+            assert(j.age === "20");
+            assert.equal(res[1].name, "sam");
+            assert.equal(res[1].age, "30");
+            done();
+        });
+    });
+    it("should emit eol event when line ending is detected as CRLF", function (done) {
+        var testData = __dirname + "/data/dataNoTrimCRLF";
+        var rs = fs.createReadStream(testData);
+        var st = rs.pipe(new Converter_1.Converter());
+        var eolCallback = sandbox.spy(function (eol) {
+            assert.equal(eol, "\r\n");
+        });
+        st.on("eol", eolCallback);
+        st.then(function () {
+            assert.equal(eolCallback.callCount, 1, 'should emit eol event once');
+            done();
+        });
+    });
+    it("should emit eol event when line ending is detected as LF", function (done) {
+        var testData = __dirname + "/data/columnArray";
+        var rs = fs.createReadStream(testData);
+        var st = rs.pipe(new Converter_1.Converter());
+        var eolCallback = sandbox.spy(function (eol) {
+            assert.equal(eol, "\n");
+        });
+        st.on("eol", eolCallback);
+        st.then(function () {
+            assert.equal(eolCallback.callCount, 1, 'should emit eol event once');
+            done();
+        });
+    });
+    it("should remove the Byte Order Mark (BOM) from input", function (done) {
+        var testData = __dirname + "/data/dataNoTrimBOM";
+        var rs = fs.createReadStream(testData);
+        var st = rs.pipe(new Converter_1.Converter({
+            trim: false
+        }));
+        st.then(function (res) {
+            var j = res[0];
+            assert(res.length === 2);
+            assert(j.name === "joe");
+            assert(j.age === "20");
+            done();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/test/testCSVConverter.ts","sources":["/Users/kxiang/work/projects/csv2json/test/testCSVConverter.ts"],"names":[],"mappings":"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","sourcesContent":["import {Converter} from \"../src/Converter\";\nimport csv from \"../src\";\nvar assert = require(\"assert\");\nvar fs = require(\"fs\");\nvar sandbox = require(\"sinon\").sandbox.create();\nvar file = __dirname + \"/data/testData\";\nvar trailCommaData = __dirname + \"/data/trailingComma\";\ndescribe(\"CSV Converter\", function () {\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  it(\"should create new instance of csv\", function () {\n    var obj = new Converter();\n    assert(obj);\n  });\n\n  it(\"should read from a stream\", function (done) {\n    var obj = new Converter();\n    var stream = fs.createReadStream(file);\n    obj.then(function (obj) {\n      assert.equal(obj.length, 2);\n      done();\n    });\n    stream.pipe(obj);\n  });\n\n  it(\"should call onNext once a row is parsed.\", function (done) {\n    var obj = new Converter();\n    var stream = fs.createReadStream(file);\n    var called = false;\n    obj.subscribe(function (resultRow) {\n      assert(resultRow);\n      called = true;\n    });\n    obj.on(\"done\", function () {\n      assert(called);\n      done();\n    });\n    stream.pipe(obj);\n  });\n\n  it(\"should emit end_parsed message once it is finished.\", function (done) {\n    var obj = new Converter();\n    obj.then(function (result) {\n      assert(result);\n      assert(result.length === 2);\n      assert(result[0].date);\n      assert(result[0].employee);\n      assert(result[0].employee.name);\n      assert(result[0].employee.age);\n      assert(result[0].employee.number);\n      assert(result[0].employee.key.length === 2);\n      assert(result[0].address.length === 2);\n      done();\n    });\n    fs.createReadStream(file).pipe(obj);\n  });\n\n  it(\"should handle traling comma gracefully\", function (done) {\n    var stream = fs.createReadStream(trailCommaData);\n    var obj = new Converter();\n    obj.then(function (result) {\n      assert(result);\n      assert(result.length > 0);\n      done();\n    });\n    stream.pipe(obj);\n  });\n\n  it(\"should handle comma in column which is surrounded by qoutes\", function (done) {\n    var testData = __dirname + \"/data/dataWithComma\";\n    var rs = fs.createReadStream(testData);\n    var obj = new Converter({\n      \"quote\": \"#\"\n    });\n    obj.then(function (result) {\n      assert(result[0].col1 === \"\\\"Mini. Sectt\");\n      assert.equal(result[3].col2, \"125001,fenvkdsf\");\n      // console.log(result);\n      done();\n    });\n    rs.pipe(obj);\n  });\n\n  it(\"should be able to convert a csv to column array data\", function (done) {\n    var columArrData = __dirname + \"/data/columnArray\";\n    var rs = fs.createReadStream(columArrData);\n    var result:any = {};\n    var csvConverter = new Converter();\n    //end_parsed will be emitted once parsing finished\n    csvConverter.then(function () {\n      assert(result.TIMESTAMP.length === 5);\n      done();\n    });\n\n    //record_parsed will be emitted each time a row has been parsed.\n    csvConverter.subscribe(function (resultRow, rowIndex) {\n      for (var key in resultRow) {\n        if (resultRow.hasOwnProperty(key)) {\n          if (!result[key] || !(result[key] instanceof Array)) {\n            result[key] = [];\n          }\n          result[key][rowIndex] = resultRow[key];\n        }\n      }\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should be able to convert csv string directly\", function (done) {\n    var testData = __dirname + \"/data/testData\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    //end_parsed will be emitted once parsing finished\n    csvConverter.then(function (jsonObj) {\n      assert.equal(jsonObj.length, 2);\n    });\n    csvConverter.fromString(data).then(function (jsonObj) {\n      assert(jsonObj.length === 2);\n      done();\n    });\n  });\n\n  it(\"should be able to convert csv string with error\", function (done) {\n    var testData = __dirname + \"/data/dataWithUnclosedQuotes\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    csvConverter.fromString(data).then(undefined, function (err) {\n      assert(err);\n      assert.equal(err.err, \"unclosed_quote\");\n      done();\n    });\n  });\n\n  it(\"should be able to convert csv string without callback provided\", function (done) {\n    var testData = __dirname + \"/data/testData\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    //end_parsed will be emitted once parsing finished\n    csvConverter.then(function (jsonObj) {\n      assert(jsonObj.length === 2);\n      done();\n    });\n    csvConverter.fromString(data);\n  });\n\n  it(\"should be able to handle columns with double quotes\", function (done) {\n    var testData = __dirname + \"/data/dataWithQoutes\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    csvConverter.fromString(data).then(function (jsonObj) {\n      assert(jsonObj[0].TIMESTAMP === '13954264\"22', JSON.stringify(jsonObj[0].TIMESTAMP));\n\n      assert(jsonObj[1].TIMESTAMP === 'abc, def, ccc', JSON.stringify(jsonObj[1].TIMESTAMP));\n      done();\n    });\n  });\n\n  it(\"should be able to handle columns with two double quotes\", function (done) {\n    var testData = __dirname + \"/data/twodoublequotes\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    csvConverter.fromString(data).then(function (jsonObj) {\n      assert.equal(jsonObj[0].title, \"\\\"\");\n      assert.equal(jsonObj[0].data, \"xyabcde\");\n      assert.equal(jsonObj[0].uuid, \"fejal\\\"eifa\");\n      assert.equal(jsonObj[0].fieldA, \"bnej\\\"\\\"falkfe\");\n      assert.equal(jsonObj[0].fieldB, \"\\\"eisjfes\\\"\");\n      done();\n    });\n  });\n\n  it(\"should handle empty csv file\", function (done) {\n    var testData = __dirname + \"/data/emptyFile\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter();\n    csvConverter.then(function (jsonObj) {\n      assert(jsonObj.length === 0);\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should parse large csv file\", function (done) {\n    var testData = __dirname + \"/data/large-csv-sample.csv\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter();\n    var count = 0;\n    csvConverter.subscribe(function () {\n      //console.log(arguments);\n      count++;\n    });\n    csvConverter.then(function () {\n      assert(count === 5290);\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should parse data and covert to specific types\", function (done) {\n    var testData = __dirname + \"/data/dataWithType\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter({\n      checkType: true,\n      colParser: {\n        \"column6\": \"string\",\n        \"column7\": \"string\"\n      }\n    });\n    csvConverter.subscribe(function (d) {\n      assert(typeof d.column1 === \"number\");\n      assert(typeof d.column2 === \"string\");\n      assert.equal(d[\"colume4\"], \"someinvaliddate\");\n      assert(d.column5.hello === \"world\");\n      assert(d.column6 === '{\"hello\":\"world\"}');\n      assert(d.column7 === \"1234\");\n      assert(d.column8 === \"abcd\");\n      assert(d.column9 === true);\n      assert(d.column10[0] === 23);\n      assert(d.column10[1] === 31);\n      assert(d.column11[0].hello === \"world\");\n      assert(d[\"name#!\"] === false);\n    });\n    csvConverter.on(\"done\", function () {\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should turn off field type check\", function (done) {\n    var testData = __dirname + \"/data/dataWithType\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter({\n      checkType: false\n    });\n    csvConverter.subscribe(function (d) {\n      assert(typeof d.column1 === \"string\");\n      assert(typeof d.column2 === \"string\");\n      assert(d[\"column3\"] === \"2012-01-01\");\n      assert(d[\"colume4\"] === \"someinvaliddate\");\n      assert(d.column5 === '{\"hello\":\"world\"}');\n      assert.equal(d[\"column6\"], '{\"hello\":\"world\"}');\n      assert(d[\"column7\"] === \"1234\");\n      assert(d[\"column8\"] === \"abcd\");\n      assert(d.column9 === \"true\");\n      assert(d.column10[0] === \"23\");\n      assert(d.column10[1] === \"31\");\n      assert(d[\"name#!\"] === 'false');\n    });\n    csvConverter.then(function () {\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should emit data event correctly\", function (done) {\n    var testData = __dirname + \"/data/large-csv-sample.csv\";\n\n    var csvConverter = new Converter({\n    });\n    var count = 0;\n    csvConverter.on(\"data\", function (d) {\n      count++;\n    });\n    csvConverter.on(\"end\", function () {\n      assert.equal(count, 5290);\n      done();\n    });\n    var rs = fs.createReadStream(testData);\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should process column with linebreaks\", function (done) {\n    var testData = __dirname + \"/data/lineBreak\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter({\n      checkType: true\n    });\n    csvConverter.subscribe(function (d) {\n      assert(d.Period === 13);\n      assert(d[\"Apparent age\"] === \"Unknown\");\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"be able to ignore empty columns\", function (done) {\n    var testData = __dirname + \"/data/dataIgnoreEmpty\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(csv({ ignoreEmpty: true }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 3);\n      assert(j.col2.length === 2);\n      assert(j.col2[1] === \"d3\");\n      assert(j.col4.col3 === undefined);\n      assert(j.col4.col5 === \"world\");\n      assert(res[1].col1 === \"d2\");\n      assert(res[2].col1 === \"d4\");\n      done();\n    });\n  });\n\n  it(\"should allow no header\", function (done) {\n    var testData = __dirname + \"/data/noheadercsv\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({ noheader: true }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 5);\n      assert(j.field1 === \"CC102-PDMI-001\");\n      assert(j.field2 === \"eClass_5.1.3\");\n      done();\n    });\n  });\n\n  it(\"should allow customised header\", function (done) {\n    var testData = __dirname + \"/data/noheadercsv\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({\n      noheader: true,\n      headers: [\"a\", \"b\"]\n    }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 5);\n      assert(j.a === \"CC102-PDMI-001\");\n      assert(j.b === \"eClass_5.1.3\");\n      assert(j.field3 === \"10/3/2014\");\n      done();\n    });\n  });\n\n  it(\"should allow customised header to override existing header\", function (done) {\n    var testData = __dirname + \"/data/complexJSONCSV\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({\n      headers: []\n    }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 2);\n      assert(j.field1 === \"Food Factory\");\n      assert(j.field2 === \"Oscar\");\n      done();\n    });\n  });\n\n  it(\"should handle when there is an empty string\", function (done) {\n    var testData = __dirname + \"/data/dataWithEmptyString\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({\n      noheader: true,\n      headers: [\"a\", \"b\", \"c\"],\n      checkType: true\n    }));\n    st.then(function (res) {\n      var j = res[0];\n\n      // assert(res.length===2);\n      assert(j.a === \"green\");\n      assert(j.b === 40);\n      assert.equal(j.c, \"\");\n      done();\n    });\n  });\n\n  it(\"should detect eol correctly when first chunk is smaller than header row length\", function (done) {\n    var testData = __dirname + \"/data/dataNoTrimCRLF\";\n    var rs = fs.createReadStream(testData, { highWaterMark: 3 });\n\n    var st = rs.pipe(new Converter({\n      trim: false\n    }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 2);\n      assert(j.name === \"joe\");\n      assert(j.age === \"20\");\n      assert.equal(res[1].name, \"sam\");\n      assert.equal(res[1].age, \"30\");\n      done();\n    });\n  });\n\n  it(\"should detect eol correctly when first chunk ends in middle of CRLF line break\", function (done) {\n    var testData = __dirname + \"/data/dataNoTrimCRLF\";\n    var rs = fs.createReadStream(testData, { highWaterMark: 9 });\n\n    var st = rs.pipe(new Converter({\n      trim: false\n    }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 2);\n      assert(j.name === \"joe\");\n      assert(j.age === \"20\");\n      assert.equal(res[1].name, \"sam\");\n      assert.equal(res[1].age, \"30\");\n      done();\n    });\n  });\n\n  it(\"should emit eol event when line ending is detected as CRLF\", function (done) {\n    var testData = __dirname + \"/data/dataNoTrimCRLF\";\n    var rs = fs.createReadStream(testData);\n\n    var st = rs.pipe(new Converter());\n    var eolCallback = sandbox.spy(function (eol) {\n      assert.equal(eol, \"\\r\\n\");\n    });\n    st.on(\"eol\", eolCallback);\n    st.then(function () {\n      assert.equal(eolCallback.callCount, 1, 'should emit eol event once');\n      done();\n    })\n  });\n\n  it(\"should emit eol event when line ending is detected as LF\", function (done) {\n    var testData = __dirname + \"/data/columnArray\";\n    var rs = fs.createReadStream(testData);\n\n    var st = rs.pipe(new Converter());\n    var eolCallback = sandbox.spy(function (eol) {\n      assert.equal(eol, \"\\n\");\n    });\n    st.on(\"eol\", eolCallback);\n    st.then(function () {\n      assert.equal(eolCallback.callCount, 1, 'should emit eol event once');\n      done();\n    })\n  });\n\n  it(\"should remove the Byte Order Mark (BOM) from input\", function (done) {\n    var testData = __dirname + \"/data/dataNoTrimBOM\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({\n      trim: false\n    }));\n    st.then( function (res) {\n      var j = res[0];\n\n      assert(res.length===2);\n      assert(j.name === \"joe\");\n      assert(j.age === \"20\");\n      done();\n    });\n  });\n});\n"]}

.ts-node/4c960549d...777abbe25614c4f67780bdd3d4f82f7da832.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function bufFromString(str) {
+    var length = Buffer.byteLength(str);
+    var buffer = Buffer.allocUnsafe
+        ? Buffer.allocUnsafe(length)
+        : new Buffer(length);
+    buffer.write(str);
+    return buffer;
+}
+exports.bufFromString = bufFromString;
+function emptyBuffer() {
+    var buffer = Buffer.allocUnsafe
+        ? Buffer.allocUnsafe(0)
+        : new Buffer(0);
+    return buffer;
+}
+exports.emptyBuffer = emptyBuffer;
+function filterArray(arr, filter) {
+    var rtn = [];
+    for (var i = 0; i < arr.length; i++) {
+        if (filter.indexOf(i) > -1) {
+            rtn.push(arr[i]);
+        }
+    }
+    return rtn;
+}
+exports.filterArray = filterArray;
+exports.trimLeft = String.prototype.trimLeft ? function trimLeftNative(str) {
+    return str.trimLeft();
+} : function trimLeftRegExp(str) {
+    return str.replace(/^\s+/, "");
+};
+exports.trimRight = String.prototype.trimRight ? function trimRightNative(str) {
+    return str.trimRight();
+} : function trimRightRegExp(str) {
+    return str.replace(/\s+$/, "");
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy91dGlsLnRzIiwic291cmNlcyI6WyIvVXNlcnMva3hpYW5nL3dvcmsvcHJvamVjdHMvY3N2Mmpzb24vc3JjL3V0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx1QkFBOEIsR0FBVztJQUN2QyxJQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3RDLElBQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxXQUFXO1FBQy9CLENBQUMsQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQztRQUM1QixDQUFDLENBQUMsSUFBSSxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDdkIsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNsQixPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDO0FBUEQsc0NBT0M7QUFFRDtJQUNFLElBQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxXQUFXO1FBQy9CLENBQUMsQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztRQUN2QixDQUFDLENBQUMsSUFBSSxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDbEIsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQztBQUxELGtDQUtDO0FBRUQscUJBQTRCLEdBQVUsRUFBRSxNQUFnQjtJQUN0RCxJQUFNLEdBQUcsR0FBVSxFQUFFLENBQUM7SUFDdEIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFLEVBQUU7UUFDbkMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFO1lBQzFCLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7U0FDbEI7S0FDRjtJQUNELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQztBQVJELGtDQVFDO0FBRVksUUFBQSxRQUFRLEdBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUEsQ0FBQyxDQUFBLHdCQUF3QixHQUFVO0lBQ2hGLE9BQU8sR0FBRyxDQUFDLFFBQVEsRUFBRSxDQUFDO0FBQ3hCLENBQUMsQ0FBQSxDQUFDLENBQUEsd0JBQXdCLEdBQVU7SUFDbEMsT0FBTyxHQUFHLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsQ0FBQztBQUNqQyxDQUFDLENBQUE7QUFFWSxRQUFBLFNBQVMsR0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQSxDQUFDLENBQUEseUJBQXlCLEdBQVU7SUFDbkYsT0FBTyxHQUFHLENBQUMsU0FBUyxFQUFFLENBQUM7QUFDekIsQ0FBQyxDQUFBLENBQUMsQ0FBQSx5QkFBeUIsR0FBVTtJQUNuQyxPQUFPLEdBQUcsQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBQ2pDLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBidWZGcm9tU3RyaW5nKHN0cjogc3RyaW5nKTogQnVmZmVyIHtcbiAgY29uc3QgbGVuZ3RoID0gQnVmZmVyLmJ5dGVMZW5ndGgoc3RyKTtcbiAgY29uc3QgYnVmZmVyID0gQnVmZmVyLmFsbG9jVW5zYWZlXG4gICAgPyBCdWZmZXIuYWxsb2NVbnNhZmUobGVuZ3RoKVxuICAgIDogbmV3IEJ1ZmZlcihsZW5ndGgpO1xuICBidWZmZXIud3JpdGUoc3RyKTtcbiAgcmV0dXJuIGJ1ZmZlcjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGVtcHR5QnVmZmVyKCk6IEJ1ZmZlcntcbiAgY29uc3QgYnVmZmVyID0gQnVmZmVyLmFsbG9jVW5zYWZlXG4gICAgPyBCdWZmZXIuYWxsb2NVbnNhZmUoMClcbiAgICA6IG5ldyBCdWZmZXIoMCk7XG4gIHJldHVybiBidWZmZXI7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBmaWx0ZXJBcnJheShhcnI6IGFueVtdLCBmaWx0ZXI6IG51bWJlcltdKTogYW55W10ge1xuICBjb25zdCBydG46IGFueVtdID0gW107XG4gIGZvciAobGV0IGkgPSAwOyBpIDwgYXJyLmxlbmd0aDsgaSsrKSB7XG4gICAgaWYgKGZpbHRlci5pbmRleE9mKGkpID4gLTEpIHtcbiAgICAgIHJ0bi5wdXNoKGFycltpXSk7XG4gICAgfVxuICB9XG4gIHJldHVybiBydG47XG59XG5cbmV4cG9ydCBjb25zdCB0cmltTGVmdD1TdHJpbmcucHJvdG90eXBlLnRyaW1MZWZ0P2Z1bmN0aW9uIHRyaW1MZWZ0TmF0aXZlKHN0cjpzdHJpbmcpe1xuICByZXR1cm4gc3RyLnRyaW1MZWZ0KCk7XG59OmZ1bmN0aW9uIHRyaW1MZWZ0UmVnRXhwKHN0cjpzdHJpbmcpe1xuICByZXR1cm4gc3RyLnJlcGxhY2UoL15cXHMrLywgXCJcIik7XG59XG5cbmV4cG9ydCBjb25zdCB0cmltUmlnaHQ9U3RyaW5nLnByb3RvdHlwZS50cmltUmlnaHQ/ZnVuY3Rpb24gdHJpbVJpZ2h0TmF0aXZlKHN0cjpzdHJpbmcpe1xuICByZXR1cm4gc3RyLnRyaW1SaWdodCgpO1xufTpmdW5jdGlvbiB0cmltUmlnaHRSZWdFeHAoc3RyOnN0cmluZyl7XG4gIHJldHVybiBzdHIucmVwbGFjZSgvXFxzKyQvLCBcIlwiKTtcbn1cbiJdfQ==

.ts-node/4c960549d...72d263fc7188f8adba2c85aec0c27e54ba1e.js

+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [0, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var src_1 = __importDefault(require("../src"));
+var assert_1 = __importDefault(require("assert"));
+var fs = require("fs");
+var sinon_1 = require("sinon");
+var sb = sinon_1.sandbox.create();
+describe("testCSVConverter3", function () {
+    afterEach(function () {
+        sb.restore();
+    });
+    it("should parse large csv file with UTF-8 without spliting characters", function (done) {
+        var testData = __dirname + "/data/large-utf8.csv";
+        var rs = fs.createReadStream(testData);
+        var csvConverter = src_1.default({});
+        var count = 0;
+        csvConverter.preRawData(function (csvRawData) {
+            assert_1.default(csvRawData.charCodeAt(0) < 2000);
+            return csvRawData;
+        });
+        csvConverter.on("data", function () {
+            count++;
+        });
+        csvConverter.then(function () {
+            assert_1.default(count === 5290);
+            done();
+        });
+        rs.pipe(csvConverter);
+    });
+    it("should setup customise type convert function", function (done) {
+        src_1.default({
+            checkType: true,
+            colParser: {
+                "column1": "string",
+                "column5": function (item, head, resultRow, row, i) {
+                    assert_1.default.equal(item, '{"hello":"world"}');
+                    assert_1.default.equal(head, "column5"),
+                        assert_1.default(resultRow);
+                    assert_1.default(row);
+                    assert_1.default.equal(i, 5);
+                    return "hello world";
+                }
+            }
+        })
+            .fromFile(__dirname + "/data/dataWithType")
+            .subscribe(function (json) {
+            assert_1.default.equal(typeof json.column1, "string");
+            assert_1.default.equal(json.column5, "hello world");
+            assert_1.default.strictEqual(json["name#!"], false);
+            assert_1.default.strictEqual(json["column9"], true);
+        })
+            .on('done', function () {
+            done();
+        });
+    });
+    it("should accept pipe as quote", function (done) {
+        src_1.default({
+            quote: "|",
+            output: "csv"
+        })
+            .fromFile(__dirname + "/data/pipeAsQuote")
+            .subscribe(function (csv) {
+            assert_1.default.equal(csv[2], "blahhh, blah");
+        })
+            .on('done', function () {
+            done();
+        });
+    });
+    it("emit file not exists error when try to open a non-exists file", function () {
+        var called = false;
+        var cb = sb.spy(function (err) {
+            assert_1.default(err.toString().indexOf("File does not exist") > -1);
+        });
+        return src_1.default()
+            .fromFile("somefile")
+            .subscribe(function (csv) {
+        })
+            .on("error", cb)
+            .then(function () {
+            assert_1.default(false);
+        }, function (err) {
+            assert_1.default.equal(cb.callCount, 1);
+        });
+    });
+    it("should include column that is both included and excluded", function () {
+        return src_1.default({
+            includeColumns: /b/,
+            ignoreColumns: /a|b/
+        })
+            .fromString("a,b,c\n1,2,3\n4,5,6")
+            .subscribe(function (d) {
+            assert_1.default(d.b);
+            assert_1.default(!d.a);
+        });
+    });
+    it("should allow async preLine hook", function () {
+        return src_1.default()
+            .preFileLine(function (line) {
+            return new Promise(function (resolve, reject) {
+                setTimeout(function () {
+                    resolve(line + "changed");
+                }, 20);
+            });
+        })
+            .fromString("a,b\n1,2")
+            .subscribe(function (d) {
+            assert_1.default(d.bchanged);
+            assert_1.default.equal(d.bchanged, "2changed");
+        });
+    });
+    it("should allow async subscribe function", function () {
+        return src_1.default({ trim: true })
+            .fromString("a,b,c\n    1,2,3\n    4,5,6")
+            .subscribe(function (d) {
+            return new Promise(function (resolve, reject) {
+                setTimeout(function () {
+                    d.a = 10;
+                    resolve();
+                }, 20);
+            });
+        })
+            .then(function (d) {
+            assert_1.default.equal(d[0].a, 10);
+            assert_1.default.equal(d[1].a, 10);
+        });
+    });
+    it("should propagate value to next then", function () {
+        return src_1.default({ trim: true })
+            .fromString("a,b,c\n  1,2,3\n  4,5,6")
+            .then(undefined, undefined)
+            .then(function (d) {
+            assert_1.default.equal(d.length, 2);
+            assert_1.default.equal(d[0].a, "1");
+        });
+    });
+    it("should propagate error to next then", function () {
+        return src_1.default({ trim: true })
+            .fromFile(__dirname + "/data/dataWithUnclosedQuotes")
+            .then(undefined, undefined)
+            .then(function () {
+            assert_1.default(false);
+        }, function (err) {
+            assert_1.default(err);
+            assert_1.default.equal(err.err, "unclosed_quote");
+        });
+    });
+    it("should fallback to text is number can not be parsed", function () {
+        return src_1.default({
+            colParser: {
+                "a": "number"
+            }
+        })
+            .fromString("a,b,c\n  1,2,3\n  fefe,5,6")
+            .then(function (d) {
+            assert_1.default.strictEqual(d[0].a, 1);
+            assert_1.default.equal(d[1].a, "fefe");
+        });
+    });
+    it("should omit a column", function () {
+        return src_1.default({
+            colParser: {
+                "a": "omit"
+            }
+        })
+            .fromString("a,b,c\n  1,2,3\n  fefe,5,6")
+            .then(function (d) {
+            assert_1.default.strictEqual(d[0].a, undefined);
+            assert_1.default.equal(d[1].a, undefined);
+        });
+    });
+    it("could turn off quote and should trim even quote is turned off", function () {
+        return src_1.default({
+            quote: "off",
+            trim: true
+        })
+            .fromString("a,b,c\n  \"1\",\"2\",\"3\"\n  \"fefe,5\",6")
+            .then(function (d) {
+            assert_1.default.equal(d[0].a, '"1"');
+            assert_1.default.equal(d[0].b, '"2"');
+            assert_1.default.equal(d[1].a, '"fefe');
+            assert_1.default.equal(d[1].b, '5"');
+        });
+    });
+    it("should allow ignoreEmpty with checkColumn", function () {
+        return src_1.default({
+            checkColumn: true,
+            ignoreEmpty: true
+        })
+            .fromString("date,altitude,airtime\n    2016-07-08,2000,23\n    \n    2016-07-09,3000,43")
+            .then(function (data) {
+        }, function (err) {
+            console.log(err);
+            assert_1.default(!err);
+        });
+    });
+    it("should allow quotes without content", function () {
+        var data = "a|^^|^b^";
+        return src_1.default({
+            delimiter: '|',
+            quote: '^',
+            noheader: true,
+        })
+            .fromString(data)
+            .then(function (jsonObj) {
+            assert_1.default.equal(jsonObj[0].field2, "");
+        });
+    });
+    it("should parse header with quotes correctly", function () {
+        var testData = __dirname + "/data/csvWithUnclosedHeader";
+        return src_1.default({
+            headers: ["exam_date", "sample_no", "status", "sample_type", "patient_id", "last_name", "first_name", "gender_of_patient", "patient_birth_date", "patient_note", "patient_department", "accession_number", "sample_site", "physician", "operator", "department", "note", "test_order_code", "draw_time", "approval_status", "approval_time", "report_layout", "patient_account_number", "none_1", "errors_detected_during_measurement", "age", "error_code_01", "weight", "error_code_02", "height", "error_code_03", "hcg_beta_p", "error_code_04", "troponin_i_p", "error_code_05", "ck_mb_p", "error_code_06", "d_dimer_p", "error_code_07", "hscrp_p", "error_code_08", "myoglobin_p", "error_code_09", "nt_probnp", "error_code_10", "crp", "error_code_11", "bnp", "error_code_12", "tnt", "error_code_13", "demo_p", "error_code_14", "pct", "error_code_15"]
+        })
+            .fromFile(testData)
+            .then(function (d) {
+            assert_1.default.equal(d.length, 2);
+            assert_1.default.equal(d[0].sample_no, "12669");
+        });
+    });
+    it("should stream json string correctly", function (done) {
+        var data = "a,b,c\n1,2,3\n4,5,6";
+        var hasLeftBracket = false;
+        var hasRightBracket = false;
+        src_1.default({
+            downstreamFormat: "array"
+        })
+            .fromString(data)
+            .on("data", function (d) {
+            var str = d.toString();
+            if (str[0] === "[" && str.length === 2) {
+                hasLeftBracket = true;
+            }
+            else if (str[0] === "]" && str.length === 2) {
+                hasRightBracket = true;
+            }
+            else {
+                assert_1.default.equal(str[str.length - 2], ",");
+            }
+        })
+            .on("end", function () {
+            assert_1.default.equal(hasLeftBracket, true);
+            assert_1.default.equal(hasRightBracket, true);
+            done();
+        });
+    });
+    it("should stream json line correctly", function (done) {
+        var data = "a,b,c\n1,2,3\n4,5,6";
+        src_1.default({
+            downstreamFormat: "line"
+        })
+            .fromString(data)
+            .on("data", function (d) {
+            var str = d.toString();
+            assert_1.default.notEqual(str[str.length - 2], ",");
+        })
+            .on("end", function () {
+            done();
+        });
+    });
+    it("should not send json if needEmitAll is false", function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                data = "a,b,c\n1,2,3\n4,5,6";
+                return [2 /*return*/, src_1.default({
+                        needEmitAll: false
+                    })
+                        .fromString(data)
+                        .then(function (d) {
+                        assert_1.default(d.length === 0);
+                    })];
+            });
+        });
+    });
+    it("should convert null to null object", function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                data = "a,b,c\nnull,2,3\n4,5,6";
+                return [2 /*return*/, src_1.default({
+                        nullObject: true
+                    })
+                        .fromString(data)
+                        .then(function (d) {
+                        assert_1.default.equal(d[0].a, null);
+                    })];
+            });
+        });
+    });
+    it("should process period properly", function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                data = "a..,b,c\n1,2,3\n4,5,6";
+                return [2 /*return*/, src_1.default({})
+                        .fromString(data)
+                        .then(function (d) {
+                        assert_1.default.equal(d[0]["a.."], 1);
+                        assert_1.default.equal(d[1]["a.."], 4);
+                    })];
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/test/testCSVConverter3.ts","sources":["/Users/kxiang/work/projects/csv2json/test/testCSVConverter3.ts"],"names":[],"mappings":"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","sourcesContent":["import csv from \"../src\";\nimport assert from \"assert\";\nvar fs = require(\"fs\");\nimport { sandbox } from \"sinon\";\nimport CSVError from \"../src/CSVError\";\nconst sb = sandbox.create();\ndescribe(\"testCSVConverter3\", function () {\n  afterEach(function () {\n    sb.restore();\n  });\n  it(\"should parse large csv file with UTF-8 without spliting characters\", function (done) {\n    var testData = __dirname + \"/data/large-utf8.csv\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = csv({\n    });\n    var count = 0;\n    csvConverter.preRawData(function (csvRawData) {\n      assert(csvRawData.charCodeAt(0) < 2000);\n      return csvRawData;\n    })\n    csvConverter.on(\"data\", function () {\n      count++;\n    });\n    csvConverter.then(function () {\n      assert(count === 5290);\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n  it(\"should setup customise type convert function\", function (done) {\n    csv({\n      checkType: true,\n      colParser: {\n        \"column1\": \"string\",\n        \"column5\": function (item, head, resultRow, row, i) {\n          assert.equal(item, '{\"hello\":\"world\"}');\n          assert.equal(head, \"column5\"),\n            assert(resultRow);\n          assert(row);\n          assert.equal(i, 5);\n          return \"hello world\";\n        }\n      }\n    })\n      .fromFile(__dirname + \"/data/dataWithType\")\n      .subscribe(function (json) {\n        assert.equal(typeof json.column1, \"string\");\n        assert.equal(json.column5, \"hello world\");\n        assert.strictEqual(json[\"name#!\"], false);\n        assert.strictEqual(json[\"column9\"], true);\n      })\n      .on('done', function () {\n        done()\n      });\n  })\n  it(\"should accept pipe as quote\", function (done) {\n    csv({\n      quote: \"|\",\n      output: \"csv\"\n    })\n      .fromFile(__dirname + \"/data/pipeAsQuote\")\n      .subscribe(function (csv) {\n        assert.equal(csv[2], \"blahhh, blah\");\n      })\n      .on('done', function () {\n        done()\n      });\n  })\n  it(\"emit file not exists error when try to open a non-exists file\", function () {\n    let called = false;\n    const cb = sb.spy((err) => {\n      assert(err.toString().indexOf(\"File does not exist\") > -1);\n    });\n    return csv()\n      .fromFile(\"somefile\")\n      .subscribe(function (csv) {\n\n      })\n      .on(\"error\", cb)\n      .then(() => {\n        assert(false);\n      }, (err) => {\n        assert.equal(cb.callCount, 1);\n      })\n\n  })\n  it(\"should include column that is both included and excluded\", () => {\n    return csv({\n      includeColumns: /b/,\n      ignoreColumns: /a|b/\n    })\n      .fromString(`a,b,c\n1,2,3\n4,5,6`)\n      .subscribe((d) => {\n        assert(d.b);\n        assert(!d.a);\n      })\n  })\n  it(\"should allow async preLine hook\", () => {\n    return csv()\n      .preFileLine((line) => {\n        return new Promise((resolve, reject) => {\n          setTimeout(() => {\n            resolve(line + \"changed\")\n          }, 20);\n\n        })\n      })\n      .fromString(`a,b\n1,2`)\n      .subscribe((d) => {\n        assert(d.bchanged);\n        assert.equal(d.bchanged, \"2changed\");\n      })\n\n  })\n\n  it(\"should allow async subscribe function\", () => {\n    return csv({ trim: true })\n      .fromString(`a,b,c\n    1,2,3\n    4,5,6`)\n      .subscribe((d) => {\n        return new Promise((resolve, reject) => {\n          setTimeout(() => {\n            d.a = 10;\n            resolve();\n          }, 20);\n        })\n      })\n      .then((d) => {\n        assert.equal(d[0].a, 10);\n        assert.equal(d[1].a, 10);\n      })\n  })\n  it(\"should propagate value to next then\", () => {\n    return csv({ trim: true })\n      .fromString(`a,b,c\n  1,2,3\n  4,5,6`)\n      .then(undefined, undefined)\n      .then((d) => {\n        assert.equal(d.length, 2);\n        assert.equal(d[0].a, \"1\");\n      })\n\n  })\n  it(\"should propagate error to next then\", () => {\n    return csv({ trim: true })\n      .fromFile(__dirname + \"/data/dataWithUnclosedQuotes\")\n      .then(undefined, undefined)\n      .then(() => {\n        assert(false)\n      }, (err: CSVError) => {\n        assert(err);\n        assert.equal(err.err, \"unclosed_quote\");\n      })\n  })\n  it(\"should fallback to text is number can not be parsed\", () => {\n    return csv({\n      colParser: {\n        \"a\": \"number\"\n      }\n    })\n      .fromString(`a,b,c\n  1,2,3\n  fefe,5,6`)\n      .then((d) => {\n        assert.strictEqual(d[0].a, 1);\n        assert.equal(d[1].a, \"fefe\");\n      })\n  })\n  it(\"should omit a column\", () => {\n    return csv({\n      colParser: {\n        \"a\": \"omit\"\n      }\n    })\n      .fromString(`a,b,c\n  1,2,3\n  fefe,5,6`)\n      .then((d) => {\n        assert.strictEqual(d[0].a, undefined);\n        assert.equal(d[1].a, undefined);\n      })\n  })\n  it(\"could turn off quote and should trim even quote is turned off\", () => {\n    return csv({\n      quote: \"off\",\n      trim: true\n    })\n      .fromString(`a,b,c\n  \"1\",\"2\",\"3\"\n  \"fefe,5\",6`)\n      .then((d) => {\n        assert.equal(d[0].a, '\"1\"');\n        assert.equal(d[0].b, '\"2\"');\n        assert.equal(d[1].a, '\"fefe');\n        assert.equal(d[1].b, '5\"');\n      })\n  })\n  it(\"should allow ignoreEmpty with checkColumn\", () => {\n    return csv({\n      checkColumn: true,\n      ignoreEmpty: true\n    })\n      .fromString(`date,altitude,airtime\n    2016-07-08,2000,23\n    \n    2016-07-09,3000,43`)\n      .then((data) => {\n\n      }, (err) => {\n        console.log(err);\n        assert(!err);\n      })\n  });\n  it(\"should allow quotes without content\", () => {\n    const data = \"a|^^|^b^\";\n    return csv({\n      delimiter: '|',\n      quote: '^',\n      noheader: true,\n    })\n      .fromString(data)\n      .then((jsonObj) => {\n        assert.equal(jsonObj[0].field2, \"\");\n      });\n  })\n  it(\"should parse header with quotes correctly\", function () {\n    var testData = __dirname + \"/data/csvWithUnclosedHeader\";\n    return csv({\n      headers: [\"exam_date\", \"sample_no\", \"status\", \"sample_type\", \"patient_id\", \"last_name\", \"first_name\", \"gender_of_patient\", \"patient_birth_date\", \"patient_note\", \"patient_department\", \"accession_number\", \"sample_site\", \"physician\", \"operator\", \"department\", \"note\", \"test_order_code\", \"draw_time\", \"approval_status\", \"approval_time\", \"report_layout\", \"patient_account_number\", \"none_1\", \"errors_detected_during_measurement\", \"age\", \"error_code_01\", \"weight\", \"error_code_02\", \"height\", \"error_code_03\", \"hcg_beta_p\", \"error_code_04\", \"troponin_i_p\", \"error_code_05\", \"ck_mb_p\", \"error_code_06\", \"d_dimer_p\", \"error_code_07\", \"hscrp_p\", \"error_code_08\", \"myoglobin_p\", \"error_code_09\", \"nt_probnp\", \"error_code_10\", \"crp\", \"error_code_11\", \"bnp\", \"error_code_12\", \"tnt\", \"error_code_13\", \"demo_p\", \"error_code_14\", \"pct\", \"error_code_15\"]\n    })\n      .fromFile(testData)\n      .then((d) => {\n        assert.equal(d.length, 2);\n        assert.equal(d[0].sample_no, \"12669\");\n      })\n\n  });\n  it (\"should stream json string correctly\",function(done){\n    const data=`a,b,c\n1,2,3\n4,5,6`\n    let hasLeftBracket=false;\n    let hasRightBracket=false;\n    csv({\n      downstreamFormat:\"array\"\n    })\n    .fromString(data)\n    .on(\"data\",(d)=>{\n      const str=d.toString();\n      if (str[0]===\"[\" && str.length ===2){\n        hasLeftBracket=true;\n      }else if (str[0]===\"]\" && str.length===2){\n        hasRightBracket=true;\n      }else{\n        assert.equal(str[str.length-2],\",\");\n      }\n      \n    })\n    .on(\"end\",()=>{\n      assert.equal(hasLeftBracket,true);\n      assert.equal(hasRightBracket,true);\n      done();\n    })\n  })\n  it (\"should stream json line correctly\",function(done){\n    const data=`a,b,c\n1,2,3\n4,5,6`\n    csv({\n      downstreamFormat:\"line\"\n    })\n    .fromString(data)\n    .on(\"data\",(d)=>{\n      const str=d.toString();\n      \n      assert.notEqual(str[str.length-2],\",\");\n    })\n    .on(\"end\",()=>{\n      done();\n    })\n  })\n  it (\"should not send json if needEmitAll is false\",async function(){\n    const data=`a,b,c\n1,2,3\n4,5,6`\n    return csv({\n      needEmitAll:false\n    })\n    .fromString(data)\n    .then((d)=>{\n      assert(d.length===0);\n    })\n  })\n  it (\"should convert null to null object\",async function(){\n    const data=`a,b,c\nnull,2,3\n4,5,6`\n    return csv({\n      nullObject:true\n    })\n    .fromString(data)\n    .then((d)=>{\n      assert.equal(d[0].a,null)\n    })\n  })\n  it (\"should process period properly\",async function(){\n    const data=`a..,b,c\n1,2,3\n4,5,6`\n    return csv({\n    })\n    .fromString(data)\n    .then((d)=>{\n      assert.equal(d[0][\"a..\"],1);\n      assert.equal(d[1][\"a..\"],4);\n    })\n  })\n});\n"]}

.ts-node/4c960549d...8b891eb80498ee4ab50c99085e120ad44307.js

+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var CSVError = /** @class */ (function (_super) {
+    __extends(CSVError, _super);
+    function CSVError(err, line, extra) {
+        var _this = _super.call(this, "Error: " + err + ". JSON Line number: " + line + (extra ? " near: " + extra : "")) || this;
+        _this.err = err;
+        _this.line = line;
+        _this.extra = extra;
+        _this.name = "CSV Parse Error";
+        return _this;
+    }
+    CSVError.column_mismatched = function (index, extra) {
+        return new CSVError("column_mismatched", index, extra);
+    };
+    CSVError.unclosed_quote = function (index, extra) {
+        return new CSVError("unclosed_quote", index, extra);
+    };
+    CSVError.fromJSON = function (obj) {
+        return new CSVError(obj.err, obj.line, obj.extra);
+    };
+    CSVError.prototype.toJSON = function () {
+        return {
+            err: this.err,
+            line: this.line,
+            extra: this.extra
+        };
+    };
+    return CSVError;
+}(Error));
+exports.default = CSVError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/4c960549d...32bd3d2a0b578a3d58bf502142d57979736c.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Converter_1 = require("../src/Converter");
+var assert = require("assert");
+var fs = require("fs");
+describe("Converter error handling", function () {
+    it("should handle quote not closed", function (done) {
+        var rs = fs.createReadStream(__dirname + "/data/dataWithUnclosedQuotes");
+        var conv = new Converter_1.Converter({});
+        conv.on("error", function (err) {
+            assert(err.err === "unclosed_quote");
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should handle column number mismatched error", function (done) {
+        var rs = fs.createReadStream(__dirname + "/data/dataWithMismatchedColumn");
+        var conv = new Converter_1.Converter({
+            checkColumn: true
+        });
+        var tested = false;
+        conv.on("error", function (err) {
+            if (tested === false) {
+                assert(err.err === "column_mismatched");
+                tested = true;
+                // done();
+            }
+        });
+        conv.on('done', function () {
+            assert(tested);
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should treat quote not closed as column_mismatched when alwaysSplitAtEOL is true", function (done) {
+        var rs = fs.createReadStream(__dirname + "/data/dataWithUnclosedQuotes");
+        var conv = new Converter_1.Converter({
+            checkColumn: true,
+            alwaysSplitAtEOL: true,
+        });
+        var tested = false;
+        conv.on("error", function (err) {
+            if (tested === false) {
+                assert(err.err === "column_mismatched");
+                tested = true;
+            }
+        });
+        conv.on('done', function () {
+            assert(tested);
+            done();
+        });
+        rs.pipe(conv);
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/4c960549d...115d1ca9f4258e909100787837de7b2c2dde.js

+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [0, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ProcessorLocal_1 = require("./ProcessorLocal");
+var Converter_1 = require("./Converter");
+var fs_1 = require("fs");
+var path_1 = __importDefault(require("path"));
+var assert_1 = __importDefault(require("assert"));
+var dataDir = path_1.default.join(__dirname, "../test/data/");
+describe("ProcessLocal", function () {
+    it("should process csv chunks and output json", function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var processor, data, lines, line0;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        processor = new ProcessorLocal_1.ProcessorLocal(new Converter_1.Converter());
+                        data = fs_1.readFileSync(dataDir + "/complexJSONCSV");
+                        return [4 /*yield*/, processor.process(data)];
+                    case 1:
+                        lines = _a.sent();
+                        assert_1.default(lines.length === 2);
+                        line0 = lines[0];
+                        assert_1.default.equal(line0.fieldA.title, "Food Factory");
+                        assert_1.default.equal(line0.fieldA.children.length, 2);
+                        assert_1.default.equal(line0.fieldA.children[1].employee[0].name, "Tim");
+                        return [2 /*return*/];
+                }
+            });
+        });
+    });
+    it("should process csv chunks and output csv rows", function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var processor, data, lines;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        processor = new ProcessorLocal_1.ProcessorLocal(new Converter_1.Converter({ output: "line" }));
+                        data = fs_1.readFileSync(dataDir + "/complexJSONCSV");
+                        return [4 /*yield*/, processor.process(data)];
+                    case 1:
+                        lines = _a.sent();
+                        assert_1.default(lines.length === 2);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    });
+    it("should return empty array if preRawHook removed the data", function () {
+        var conv = new Converter_1.Converter();
+        conv.preRawData(function (str) {
+            return "";
+        });
+        var processor = new ProcessorLocal_1.ProcessorLocal(conv);
+        var data = fs_1.readFileSync(dataDir + "/complexJSONCSV");
+        return processor.process(data)
+            .then(function (list) {
+            assert_1.default.equal(list.length, 0);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9Qcm9jZXNzb3JMb2NhbC50ZXN0LnRzIiwic291cmNlcyI6WyIvVXNlcnMva3hpYW5nL3dvcmsvcHJvamVjdHMvY3N2Mmpzb24vc3JjL1Byb2Nlc3NvckxvY2FsLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFnRDtBQUNoRCx5Q0FBd0M7QUFFeEMseUJBQWdDO0FBQ2hDLDhDQUF3QjtBQUN4QixrREFBNEI7QUFFNUIsSUFBTSxPQUFPLEdBQUMsY0FBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUMsZUFBZSxDQUFDLENBQUM7QUFDbkQsUUFBUSxDQUFDLGNBQWMsRUFBQztJQUN0QixFQUFFLENBQUUsMkNBQTJDLEVBQUM7Ozs7Ozt3QkFDeEMsU0FBUyxHQUFDLElBQUksK0JBQWMsQ0FBQyxJQUFJLHFCQUFTLEVBQUUsQ0FBQyxDQUFDO3dCQUM5QyxJQUFJLEdBQUMsaUJBQVksQ0FBQyxPQUFPLEdBQUMsaUJBQWlCLENBQUMsQ0FBQzt3QkFDdkMscUJBQU0sU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBQTs7d0JBQW5DLEtBQUssR0FBQyxTQUE2Qjt3QkFDekMsZ0JBQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQyxDQUFDO3dCQUNyQixLQUFLLEdBQUMsS0FBSyxDQUFDLENBQUMsQ0FBZSxDQUFDO3dCQUNuQyxnQkFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBQyxjQUFjLENBQUMsQ0FBQzt3QkFDaEQsZ0JBQU0sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFDLENBQUMsQ0FBQyxDQUFDO3dCQUM3QyxnQkFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFDLEtBQUssQ0FBQyxDQUFDOzs7OztLQUMvRCxDQUFDLENBQUE7SUFDRixFQUFFLENBQUUsK0NBQStDLEVBQUM7Ozs7Ozt3QkFDNUMsU0FBUyxHQUFDLElBQUksK0JBQWMsQ0FBQyxJQUFJLHFCQUFTLENBQUMsRUFBQyxNQUFNLEVBQUMsTUFBTSxFQUFDLENBQUMsQ0FBQyxDQUFDO3dCQUM3RCxJQUFJLEdBQUMsaUJBQVksQ0FBQyxPQUFPLEdBQUMsaUJBQWlCLENBQUMsQ0FBQzt3QkFDdkMscUJBQU0sU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBQTs7d0JBQW5DLEtBQUssR0FBQyxTQUE2Qjt3QkFFekMsZ0JBQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQyxDQUFDOzs7OztLQUM1QixDQUFDLENBQUE7SUFDRixFQUFFLENBQUUsMERBQTBELEVBQUM7UUFDN0QsSUFBTSxJQUFJLEdBQUMsSUFBSSxxQkFBUyxFQUFFLENBQUM7UUFDM0IsSUFBSSxDQUFDLFVBQVUsQ0FBQyxVQUFDLEdBQUc7WUFDbEIsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDLENBQUMsQ0FBQztRQUNILElBQU0sU0FBUyxHQUFDLElBQUksK0JBQWMsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN6QyxJQUFNLElBQUksR0FBQyxpQkFBWSxDQUFDLE9BQU8sR0FBQyxpQkFBaUIsQ0FBQyxDQUFDO1FBQ25ELE9BQU8sU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUM7YUFDN0IsSUFBSSxDQUFDLFVBQUMsSUFBSTtZQUNULGdCQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUMsQ0FBQyxDQUFDLENBQUM7UUFDOUIsQ0FBQyxDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtQcm9jZXNzb3JMb2NhbH0gZnJvbSBcIi4vUHJvY2Vzc29yTG9jYWxcIjtcbmltcG9ydCB7IENvbnZlcnRlciB9IGZyb20gXCIuL0NvbnZlcnRlclwiO1xuaW1wb3J0IFAgZnJvbSBcImJsdWViaXJkXCI7XG5pbXBvcnQge3JlYWRGaWxlU3luY30gZnJvbSBcImZzXCI7XG5pbXBvcnQgcGF0aCBmcm9tIFwicGF0aFwiO1xuaW1wb3J0IGFzc2VydCBmcm9tIFwiYXNzZXJ0XCI7XG5pbXBvcnQgeyBKU09OUmVzdWx0IH0gZnJvbSBcIi4vbGluZVRvSnNvblwiO1xuY29uc3QgZGF0YURpcj1wYXRoLmpvaW4oX19kaXJuYW1lLFwiLi4vdGVzdC9kYXRhL1wiKTtcbmRlc2NyaWJlKFwiUHJvY2Vzc0xvY2FsXCIsKCk9PntcbiAgaXQgKFwic2hvdWxkIHByb2Nlc3MgY3N2IGNodW5rcyBhbmQgb3V0cHV0IGpzb25cIixhc3luYyBmdW5jdGlvbiAoKXtcbiAgICBjb25zdCBwcm9jZXNzb3I9bmV3IFByb2Nlc3NvckxvY2FsKG5ldyBDb252ZXJ0ZXIoKSk7XG4gICAgY29uc3QgZGF0YT1yZWFkRmlsZVN5bmMoZGF0YURpcitcIi9jb21wbGV4SlNPTkNTVlwiKTtcbiAgICBjb25zdCBsaW5lcz1hd2FpdCBwcm9jZXNzb3IucHJvY2VzcyhkYXRhKTtcbiAgICBhc3NlcnQobGluZXMubGVuZ3RoID09PSAyKTtcbiAgICBjb25zdCBsaW5lMD1saW5lc1swXSBhcyBKU09OUmVzdWx0O1xuICAgIGFzc2VydC5lcXVhbChsaW5lMC5maWVsZEEudGl0bGUsXCJGb29kIEZhY3RvcnlcIik7XG4gICAgYXNzZXJ0LmVxdWFsKGxpbmUwLmZpZWxkQS5jaGlsZHJlbi5sZW5ndGgsMik7XG4gICAgYXNzZXJ0LmVxdWFsKGxpbmUwLmZpZWxkQS5jaGlsZHJlblsxXS5lbXBsb3llZVswXS5uYW1lLFwiVGltXCIpO1xuICB9KVxuICBpdCAoXCJzaG91bGQgcHJvY2VzcyBjc3YgY2h1bmtzIGFuZCBvdXRwdXQgY3N2IHJvd3NcIixhc3luYyBmdW5jdGlvbiAoKXtcbiAgICBjb25zdCBwcm9jZXNzb3I9bmV3IFByb2Nlc3NvckxvY2FsKG5ldyBDb252ZXJ0ZXIoe291dHB1dDpcImxpbmVcIn0pKTtcbiAgICBjb25zdCBkYXRhPXJlYWRGaWxlU3luYyhkYXRhRGlyK1wiL2NvbXBsZXhKU09OQ1NWXCIpO1xuICAgIGNvbnN0IGxpbmVzPWF3YWl0IHByb2Nlc3Nvci5wcm9jZXNzKGRhdGEpO1xuICAgIFxuICAgIGFzc2VydChsaW5lcy5sZW5ndGggPT09IDIpO1xuICB9KVxuICBpdCAoXCJzaG91bGQgcmV0dXJuIGVtcHR5IGFycmF5IGlmIHByZVJhd0hvb2sgcmVtb3ZlZCB0aGUgZGF0YVwiLCgpPT57XG4gICAgY29uc3QgY29udj1uZXcgQ29udmVydGVyKCk7XG4gICAgY29udi5wcmVSYXdEYXRhKChzdHIpPT57XG4gICAgICByZXR1cm4gXCJcIjtcbiAgICB9KTtcbiAgICBjb25zdCBwcm9jZXNzb3I9bmV3IFByb2Nlc3NvckxvY2FsKGNvbnYpO1xuICAgIGNvbnN0IGRhdGE9cmVhZEZpbGVTeW5jKGRhdGFEaXIrXCIvY29tcGxleEpTT05DU1ZcIik7XG4gICAgcmV0dXJuIHByb2Nlc3Nvci5wcm9jZXNzKGRhdGEpXG4gICAgLnRoZW4oKGxpc3QpPT57XG4gICAgICBhc3NlcnQuZXF1YWwobGlzdC5sZW5ndGgsMCk7XG4gICAgfSlcbiAgfSlcbn0pXG5cbiJdfQ==

.ts-node/4c960549d...a99b4eb7ee0ec505f5bc404dfb198396e590.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe("CSVError", function () {
+    it("should toString()", function () {
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9DU1ZFcnJvci50ZXN0LnRzIiwic291cmNlcyI6WyIvVXNlcnMva3hpYW5nL3dvcmsvcHJvamVjdHMvY3N2Mmpzb24vc3JjL0NTVkVycm9yLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxRQUFRLENBQUMsVUFBVSxFQUFDO0lBQ2xCLEVBQUUsQ0FBRSxtQkFBbUIsRUFBQztJQUN4QixDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IENTVkVycm9yIGZyb20gXCIuL0NTVkVycm9yXCI7XG5pbXBvcnQgYXNzZXJ0IGZyb20gXCJhc3NlcnRcIjtcbmRlc2NyaWJlKFwiQ1NWRXJyb3JcIiwoKT0+e1xuICBpdCAoXCJzaG91bGQgdG9TdHJpbmcoKVwiLCgpPT57XG4gIH0pXG59KSJdfQ==

.ts-node/4c960549d...91dc885e4e64429d73b07dd25f75a49704bb.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var fileline_1 = require("./fileline");
+var Converter_1 = require("./Converter");
+var assert = require("assert");
+describe("fileline function", function () {
+    it("should convert data to multiple lines ", function () {
+        var conv = new Converter_1.Converter();
+        var data = "abcde\nefef";
+        var result = fileline_1.stringToLines(data, conv.parseRuntime);
+        assert.equal(result.lines.length, 1);
+        assert.equal(result.partial, "efef");
+        assert.equal(result.lines[0], "abcde");
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9maWxlbGluZS50ZXN0LnRzIiwic291cmNlcyI6WyIvVXNlcnMva3hpYW5nL3dvcmsvcHJvamVjdHMvY3N2Mmpzb24vc3JjL2ZpbGVsaW5lLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx1Q0FBeUM7QUFFekMseUNBQXdDO0FBQ3hDLElBQUksTUFBTSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUMvQixRQUFRLENBQUMsbUJBQW1CLEVBQUU7SUFDNUIsRUFBRSxDQUFFLHdDQUF3QyxFQUFFO1FBQzVDLElBQU0sSUFBSSxHQUFDLElBQUkscUJBQVMsRUFBRSxDQUFDO1FBQzNCLElBQUksSUFBSSxHQUFHLGFBQWEsQ0FBQztRQUN6QixJQUFJLE1BQU0sR0FBRyx3QkFBYSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDcEQsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQztRQUNyQyxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDckMsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3pDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge3N0cmluZ1RvTGluZXN9IGZyb20gXCIuL2ZpbGVsaW5lXCI7XG5pbXBvcnQgeyBtZXJnZVBhcmFtcyB9IGZyb20gXCIuL1BhcmFtZXRlcnNcIjtcbmltcG9ydCB7IENvbnZlcnRlciB9IGZyb20gXCIuL0NvbnZlcnRlclwiO1xudmFyIGFzc2VydCA9IHJlcXVpcmUoXCJhc3NlcnRcIik7XG5kZXNjcmliZShcImZpbGVsaW5lIGZ1bmN0aW9uXCIsIGZ1bmN0aW9uKCkge1xuICBpdCAoXCJzaG91bGQgY29udmVydCBkYXRhIHRvIG11bHRpcGxlIGxpbmVzIFwiLCBmdW5jdGlvbigpIHtcbiAgICBjb25zdCBjb252PW5ldyBDb252ZXJ0ZXIoKTtcbiAgICB2YXIgZGF0YSA9IFwiYWJjZGVcXG5lZmVmXCI7XG4gICAgdmFyIHJlc3VsdCA9IHN0cmluZ1RvTGluZXMoZGF0YSwgY29udi5wYXJzZVJ1bnRpbWUpO1xuICAgIGFzc2VydC5lcXVhbChyZXN1bHQubGluZXMubGVuZ3RoLCAxKTtcbiAgICBhc3NlcnQuZXF1YWwocmVzdWx0LnBhcnRpYWwsIFwiZWZlZlwiKTtcbiAgICBhc3NlcnQuZXF1YWwocmVzdWx0LmxpbmVzWzBdLCBcImFiY2RlXCIpO1xuICB9KTtcbn0pO1xuIl19

src/Result.test.ts

+import {Result} from "./Result";
+import { Converter } from "./Converter";
+import P from "bluebird";
+import {readFileSync} from "fs";
+import path from "path";
+import assert from "assert";
+import { JSONResult } from "./lineToJson";
+const dataDir=path.join(__dirname,"../test/data/");
+
+describe("Result",()=>{
+  it ("should return need push downstream based on needEmitAll parameter",function (){
+      const conv=new Converter();
+      const res=new Result(conv);
+      assert.equal(res["needEmitAll"],false);
+      conv.then();
+      assert.equal(res["needEmitAll"],true);
+      conv.parseParam.needEmitAll=false;
+      assert.equal(res["needEmitAll"],false);
+  });
+
+})
+

.travis.yml

@@ -6,4 +6,3 @@ language: node_js
   - "6"
-  - "4"
 after_success: 'npm run coveralls'
 script: "npm run travis"

bin/options.json

@@ -79,2 +79,10 @@ {
             "type": "boolean"
+        },
+        "--nullObject":{
+            "desc":"How to parse if a csv cell contains 'null'. Default false will keep 'null' as string. Change to true if a null object is needed.",
+            "type":"boolean"
+        },
+        "--downstreamFormat":{
+            "desc":"Option to set what JSON array format is needed by downstream. 'line' is also called ndjson format. This format will write lines of JSON (without square brackets and commas) to downstream. 'array' will write complete JSON array string to downstream (suitable for file writable stream etc). Default 'line'",
+            "type":"string"
         }
@@ -81,0 +89,0 @@ },

package.json

@@ -247,3 +247,3 @@ {
   ],
-  "version": "2.0.8",
+  "version": "2.0.10",
   "keywords": [
@@ -301,4 +301,5 @@ "csv",
     "dev": "tsc -w",
-    "build": "rm -Rf ./v2 && tsc && npm run build:browser",
+    "build": "rm -Rf ./v2 && tsc && npm run build:browser && npm run build:browser:window",
     "build:browser": "webpack --config ./webpack.config.js",
+    "build:browser:window": "webpack --config ./webpack.config.js --output-library-target=window --output-library=csv --output-filename=csvtojson.min.js",
     "test": "rm -Rf .ts-node && TS_NODE_CACHE_DIRECTORY=.ts-node mocha -r ts-node/register src/**/*.test.ts ./test/*.ts -R spec",
@@ -305,0 +306,0 @@ "travis": "nyc --reporter lcov mocha -r ts-node/register src/**/*.test.ts ./test/*.ts -R spec",

readme.md

@@ -29,3 +29,3 @@ [![Build Status](https://travis-ci.org/Keyang/node-csvtojson.svg?branch=master)](https://travis-ci.org/Keyang/node-csvtojson)
 * To upgrade to v2, please follow [upgrading guide](https://github.com/Keyang/node-csvtojson/blob/master/docs/csvtojson-v2.md)
-* If you are looking for documentation for `v1`, open [this page](https://github.com/Keyang/node-csvtojson/blob/master/docs/readme.v1.md).
+* If you are looking for documentation for `v1`, open [this page](https://github.com/Keyang/node-csvtojson/blob/master/docs/readme.v1.md)
 
@@ -47,2 +47,3 @@ It is still able to use v1 with `csvtojson@2.0.0`
 * [API](#api)
+* [Browser Usage](#browser-usage)
 * [Contribution](#contribution)
@@ -199,3 +200,3 @@
 * [Parameters](#parameters)
-* [Asynchronouse Result Process](#asynchronouse-result-process)
+* [Asynchronous Result Process](#asynchronous-result-process)
 * [Events](#events)
@@ -205,3 +206,2 @@ * [Hook / Transform](#hook--transform)
 * [Header Row](#header-row)
-* [Multi CPU Core Support(experimental) ](#multi-cpu-core-support)
 * [Column Parser](#column-parser)
@@ -214,3 +214,3 @@
 
-1. parser parameters
+1. Parser parameters
 2. Stream options
@@ -237,4 +237,4 @@
 * **output**: The format to be converted to. "json" (default) -- convert csv to json. "csv" -- convert csv to csv row array. "line" -- convert csv to csv line string  
-* **delimiter**: delimiter used for seperating columns. Use "auto" if delimiter is unknown in advance, in this case, delimiter will be auto-detected (by best attempt). Use an array to give a list of potential delimiters e.g. [",","|","$"]. default: ","
-* **quote**: If a column contains delimiter, it is able to use quote character to surround the column content. e.g. "hello, world" wont be split into two columns while parsing. Set to "off" will ignore all quotes. default: " (double quote)
+* **delimiter**: delimiter used for separating columns. Use "auto" if delimiter is unknown in advance, in this case, delimiter will be auto-detected (by best attempt). Use an array to give a list of potential delimiters e.g. [",","|","$"]. default: ","
+* **quote**: If a column contains delimiter, it is able to use quote character to surround the column content. e.g. "hello, world" won't be split into two columns while parsing. Set to "off" will ignore all quotes. default: " (double quote)
 * **trim**: Indicate if parser trim off spaces surrounding column content. e.g. "  content  " will be trimmed to "content". Default: true
@@ -247,3 +247,3 @@ * **checkType**: This parameter turns on and off whether check field type. Default is false. (The default is `true` if version < 1.1.4)
 * **flatKeys**: Don't interpret dots (.) and square brackets in header fields as nested object or array identifiers at all (treat them like regular characters for JSON field identifiers). Default: false.
-* **maxRowLength**: the max character a csv row could have. 0 means infinite. If max number exceeded, parser will emit "error" of "row_exceed". if a possibly corrupted csv data provided, give it a number like 65535 so the parser wont consume memory. default: 0
+* **maxRowLength**: the max character a csv row could have. 0 means infinite. If max number exceeded, parser will emit "error" of "row_exceed". if a possibly corrupted csv data provided, give it a number like 65535 so the parser won't consume memory. default: 0
 * **checkColumn**: whether check column number of a row is the same as headers. If column number mismatched headers number, an error of "mismatched_column" will be emitted.. default: false
@@ -255,11 +255,13 @@ * **eol**: End of line character. If omitted, parser will attempt to retrieve it from the first chunks of CSV data.
 * **colParser**: Allows override parsing logic for a specific column. It accepts a JSON object with fields like: `headName: <String | Function | ColParser>` . e.g. {field1:'number'} will use built-in number parser to convert value of the `field1` column to number. For more information See [details below](#column-parser)
-* **alwaysSplitAtEOL**: Always interpret each line (as defined by `eol`) as a row. This will prevent `eol` characters from being used within a row (even inside a quoted field). This ensures that misplaced quotes only break on row, and not all ensuing rows.
-
+* **alwaysSplitAtEOL**: Always interpret each line (as defined by `eol` like `\n`) as a row. This will prevent `eol` characters from being used within a row (even inside a quoted field). Default is false. Change to true if you are confident no inline line breaks (like line break in a cell which has multi line text).
+* **nullObject**: How to parse if a csv cell contains "null". Default false will keep "null" as string. Change to true if a null object is needed.
+* **downstreamFormat**: Option to set what JSON array format is needed by downstream. "line" is also called ndjson format. This format will write lines of JSON (without square brackets and commas) to downstream. "array" will write complete JSON array string to downstream (suitable for file writable stream etc). Default "line"
+* **needEmitAll**: Parser will build JSON result is `.then` is called (or await is used). If this is not desired, set this to false. Default is true. 
 All parameters can be used in Command Line tool.
 
-## Asynchronouse Result Process
+## Asynchronous Result Process
 
-Since `v2.0.0`, asynchronouse processing has been fully supported.
+Since `v2.0.0`, asynchronous processing has been fully supported.
 
-e.g. Process each JSON result asynchronousely.
+e.g. Process each JSON result asynchronously.
 
@@ -271,3 +273,3 @@ ```js
 		// Async operation on the json
-		// dont forget to call resolve and reject
+		// don't forget to call resolve and reject
 	})
@@ -303,3 +305,3 @@ })
 
-`data` event is emitted for each parsed CSV line. It passes buffer of strigified JSON in [ndjson format](http://ndjson.org/) unless `objectMode` is set true in stream option.
+`data` event is emitted for each parsed CSV line. It passes buffer of stringified JSON in [ndjson format](http://ndjson.org/) unless `objectMode` is set true in stream option.
 
@@ -316,3 +318,3 @@ ```js
 ### error
-`error` event is emitted if there is any errors happened during parsing.
+`error` event is emitted if any errors happened during parsing.
 
@@ -361,3 +363,3 @@ ```js
 
-// asynchronouse
+// asynchronous
 csv()
@@ -375,3 +377,3 @@ .preRawData((csvRawData)=>{
 
-the function is called each time a file line has been parsed in csv stream. the `lineIdx` is the file line number in the file starting with 0. 
+The function is called each time a file line has been parsed in csv stream. The `lineIdx` is the file line number in the file starting with 0. 
 
@@ -389,3 +391,3 @@ ```js
 
-// asynchronouse
+// asynchronous
 csv()
@@ -412,3 +414,3 @@ .preFileLine((fileLineString, lineIdx)=>{
 	jsonObj.myNewKey='some value'
-	// OR asynchronousely
+	// OR asynchronously
 	return new Promise((resolve,reject)=>{
@@ -504,3 +506,3 @@ jsonObj.myNewKey='some value';
 3. If original csv source has no header row but the header definition can be defined. Use `headers:[]` and `noheader:true` parameters.
-4. If original csv source has no header row and the header definition is unknow. Use `noheader:true`. This will automatically add `fieldN` header to csv cells
+4. If original csv source has no header row and the header definition is unknown. Use `noheader:true`. This will automatically add `fieldN` header to csv cells
 
@@ -597,3 +599,3 @@
 
-the returned value will be used in result JSON object. returning `undefined` will not change result JSON object. 
+The returned value will be used in result JSON object. Returning `undefined` will not change result JSON object. 
 
@@ -634,3 +636,3 @@ ### Flat key column
 2. Checkout code from your github repo to your local machine.
-3. Make code changes and dont forget add related tests.
+3. Make code changes and don't forget add related tests.
 4. Run `npm test` locally before pushing code back.
@@ -657,1 +659,41 @@ 5. Create a [Pull Request](https://help.github.com/articles/creating-a-pull-request/) on github.
 
+# Browser Usage
+
+To use `csvtojson` in browser is quite simple. There are two ways:
+
+**1. Embed script directly into script tag**
+
+There is a pre-built script located in `browser/csvtojson.min.js`. Simply include that file in a `script` tag in `index.html` page:
+
+```html
+<script src="node_modules/csvtojson/browser/csvtojson.min.js"></script>
+<!-- or use cdn -->
+<script src="https://cdn.rawgit.com/Keyang/node-csvtojson/d41f44aa/browser/csvtojson.min.js"></script>
+```
+then use a global `csv` function
+```html 
+<script>
+csv({
+	output: "csv"
+})
+.fromString("a,b,c\n1,2,3")
+.then(function(result){
+
+})
+</script>
+```
+
+
+
+**2. Use webpack or browserify**
+
+If a module packager is preferred, just simply `require("csvtojson")`:
+
+```js
+var csv=require("csvtojson");
+
+// or with import
+import * as csv from "csvtojson";
+
+//then use csv as normal
+```

src/Converter.ts

@@ -19,3 +19,3 @@ import { Transform, TransformOptions, Readable } from "stream";
 
-export class Converter extends Transform implements PromiseLike<Array<any>> {
+export class Converter extends Transform implements PromiseLike<any[]> {
   preRawData(onRawData: PreRawDataCallback): Converter {
@@ -119,7 +119,7 @@ this.runtime.preRawDataHook = onRawData;
       // console.log("BBB");
-
-      setTimeout(() => {
+      //wait for next cycle to emit the errors.
+      setImmediate(() => {
         this.result.processError(err);
         this.emit("done", err);
-      }, 0);
+      });
 
@@ -126,0 +126,0 @@ });

src/index.ts

@@ -8,4 +8,4 @@ import { TransformOptions } from "stream";
 }
-
+helper["csv"] = helper;
 helper["Converter"] = Converter;
-export =helper;
+export =helper;

src/lineToJson.ts

@@ -117,4 +117,14 @@ import { Converter } from "./Converter";
     } else {
+      
       if (head.indexOf(".") > -1) {
-        if (conv.parseParam.colParser[head] && (conv.parseParam.colParser[head] as ColumnParam).flat) {
+        const headArr=head.split(".");
+        let jsonHead=true;
+        while(headArr.length>0){
+          const headCom=headArr.shift();
+          if (headCom!.length===0){
+            jsonHead=false;
+            break;
+          }
+        }
+        if (!jsonHead || conv.parseParam.colParser[head] && (conv.parseParam.colParser[head] as ColumnParam).flat) {
           conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;
@@ -129,2 +139,5 @@ } else {
   }
+  if (conv.parseParam.nullObject ===true && value ==="null"){
+    value=null;
+  }
   conv.parseRuntime.columnValueSetter[headIdx](resultJson, head, value);
@@ -131,0 +144,0 @@ // flatSetter(resultJson, head, value);

src/Parameters.ts

@@ -69,3 +69,3 @@ export interface CSVParseParam {
   /**
-   *  Always interpret each line (as defined by eol) as a row. This will prevent eol characters from being used within a row (even inside a quoted field). This ensures that misplaced quotes only break on row, and not all ensuing rows.
+   *  Always interpret each line (as defined by eol) as a row. This will prevent eol characters from being used within a row (even inside a quoted field). Default is false. Change to true if you are confident no inline line breaks (like line break in a cell which has multi line text)
    */
@@ -77,2 +77,15 @@ alwaysSplitAtEOL: boolean;
   output: "json" | "csv" | "line";
+
+  /**
+   * Convert string "null" to null object in JSON outputs. Default is false.
+   */
+  nullObject:boolean;
+  /**
+   * Define the format required by downstream (this parameter does not work if objectMode is on). `line` -- json is emitted in a single line separated by a line breake like "json1\njson2" . `array` -- downstream requires array format like "[json1,json2]". Default is line.
+   */
+  downstreamFormat: "line" | "array";
+  /**
+   * Define whether .then(callback) returns all JSON data in its callback. Default is true. Change to false to save memory if subscribing json lines.
+   */
+  needEmitAll: boolean;
 }
@@ -106,3 +119,6 @@
     alwaysSplitAtEOL: false,
-    output: "json"
+    output: "json",
+    nullObject: false,
+    downstreamFormat:"line",
+    needEmitAll:true
   }
@@ -109,0 +125,0 @@ if (!params) {

src/Result.ts

@@ -5,3 +5,3 @@ import { Converter } from "./Converter";
 import CSVError from "./CSVError";
-
+import { EOL } from "os";
 export class Result {
@@ -19,3 +19,4 @@ private get needEmitLine(): boolean {
   private get needEmitAll(): boolean {
-    return !!this.converter.parseRuntime.then;
+    return !!this.converter.parseRuntime.then && this.converter.parseParam.needEmitAll;
+    // return !!this.converter.parseRuntime.then;
   }
@@ -26,2 +27,7 @@ private finalResult: any[] = [];
     const startPos = this.converter.parseRuntime.parsedLineNumber;
+    if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === "array") {
+      if (startPos === 0) {
+        pushDownstream(this.converter, "[" + EOL);
+      }
+    }
     // let prom: P<any>;
@@ -66,10 +72,16 @@ return new P((resolve, reject) => {
   endProcess() {
-    if (this.needEmitAll) {
+    
       if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onfulfilled) {
-        this.converter.parseRuntime.then.onfulfilled(this.finalResult);
+        if (this.needEmitAll) {
+          this.converter.parseRuntime.then.onfulfilled(this.finalResult);
+        }else{
+          this.converter.parseRuntime.then.onfulfilled([]);
+        }
       }
-    }
     if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onCompleted) {
       this.converter.parseRuntime.subscribe.onCompleted();
     }
+    if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === "array") {
+      pushDownstream(this.converter, "]" + EOL);
+    }
   }
@@ -101,11 +113,11 @@ }
         // processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);
-        if (needPushDownstream){
-          pushDownstream(conv,nextLine);
+        if (needPushDownstream) {
+          pushDownstream(conv, nextLine);
         }
-        while (offset<lines.length){
-          const line=lines[offset];
+        while (offset < lines.length) {
+          const line = lines[offset];
           hook(line, conv.parseRuntime.parsedLineNumber + offset);
           offset++;
-          if (needPushDownstream){
-            pushDownstream(conv,line);
+          if (needPushDownstream) {
+            pushDownstream(conv, line);
           }
@@ -124,7 +136,7 @@ }
       if (needPushDownstream) {
-        while (offset<lines.length) {
+        while (offset < lines.length) {
           const line = lines[offset++];
           pushDownstream(conv, line);
         }
-        
+
       }
@@ -153,3 +165,4 @@ cb();
   if (typeof res === "object" && !conv.options.objectMode) {
-    conv.push(JSON.stringify(res) + "\n", "utf8");
+    const data = JSON.stringify(res);
+    conv.push(data + (conv.parseParam.downstreamFormat === "array" ? "," + EOL : EOL), "utf8");
   } else {
@@ -156,0 +169,0 @@ conv.push(res);

src/rowSplit.ts

@@ -78,5 +78,11 @@ import { CSVParseParam } from "./Parameters";
             let count = 0;
+            let prev = "";
             for (const c of e) {
-              if (c === quote) {
+              // count quotes only if previous character is not escape char
+              if (c === quote && prev !== this.escape) {
                 count++;
+                prev = "";
+              } else {
+                // save previous char to temp variable
+                prev = c;
               }
@@ -83,0 +89,0 @@ }

test/testCSVConverter2.ts

@@ -297,3 +297,18 @@ import { Converter } from "../src/Converter";
 
-  it("should output ndjson format", function (done) {
+  it("should process escape chars when delimiter is between escaped quotes", function(done) {
+    var test_converter = new Converter({
+      escape: "\\"
+    });
+
+    var testData =
+      __dirname + "/data/dataWithSlashEscapeAndDelimiterBetweenQuotes";
+    var rs = fs.createReadStream(testData);
+    test_converter.then(function(res) {
+      assert.equal(res[0].raw, '"hello,"world"');
+      done();
+    });
+    rs.pipe(test_converter);
+  });
+
+  it("should output ndjson format", function(done) {
     var conv = new Converter();
@@ -300,0 +315,0 @@ conv.fromString("a,b,c\n1,2,3\n4,5,6")

test/testCSVConverter3.ts

 import csv from "../src";
-var assert = require("assert");
+import assert from "assert";
 var fs = require("fs");
@@ -234,11 +234,91 @@ import { sandbox } from "sinon";
     return csv({
-      headers:["exam_date","sample_no","status","sample_type","patient_id","last_name","first_name","gender_of_patient","patient_birth_date","patient_note","patient_department","accession_number","sample_site","physician","operator","department","note","test_order_code","draw_time","approval_status","approval_time","report_layout","patient_account_number","none_1","errors_detected_during_measurement","age","error_code_01","weight","error_code_02","height","error_code_03","hcg_beta_p","error_code_04","troponin_i_p","error_code_05","ck_mb_p","error_code_06","d_dimer_p","error_code_07","hscrp_p","error_code_08","myoglobin_p","error_code_09","nt_probnp","error_code_10","crp","error_code_11","bnp","error_code_12","tnt","error_code_13","demo_p","error_code_14","pct","error_code_15"]
+      headers: ["exam_date", "sample_no", "status", "sample_type", "patient_id", "last_name", "first_name", "gender_of_patient", "patient_birth_date", "patient_note", "patient_department", "accession_number", "sample_site", "physician", "operator", "department", "note", "test_order_code", "draw_time", "approval_status", "approval_time", "report_layout", "patient_account_number", "none_1", "errors_detected_during_measurement", "age", "error_code_01", "weight", "error_code_02", "height", "error_code_03", "hcg_beta_p", "error_code_04", "troponin_i_p", "error_code_05", "ck_mb_p", "error_code_06", "d_dimer_p", "error_code_07", "hscrp_p", "error_code_08", "myoglobin_p", "error_code_09", "nt_probnp", "error_code_10", "crp", "error_code_11", "bnp", "error_code_12", "tnt", "error_code_13", "demo_p", "error_code_14", "pct", "error_code_15"]
     })
-    .fromFile(testData)
+      .fromFile(testData)
+      .then((d) => {
+        assert.equal(d.length, 2);
+        assert.equal(d[0].sample_no, "12669");
+      })
+
+  });
+  it ("should stream json string correctly",function(done){
+    const data=`a,b,c
+1,2,3
+4,5,6`
+    let hasLeftBracket=false;
+    let hasRightBracket=false;
+    csv({
+      downstreamFormat:"array"
+    })
+    .fromString(data)
+    .on("data",(d)=>{
+      const str=d.toString();
+      if (str[0]==="[" && str.length ===2){
+        hasLeftBracket=true;
+      }else if (str[0]==="]" && str.length===2){
+        hasRightBracket=true;
+      }else{
+        assert.equal(str[str.length-2],",");
+      }
+      
+    })
+    .on("end",()=>{
+      assert.equal(hasLeftBracket,true);
+      assert.equal(hasRightBracket,true);
+      done();
+    })
+  })
+  it ("should stream json line correctly",function(done){
+    const data=`a,b,c
+1,2,3
+4,5,6`
+    csv({
+      downstreamFormat:"line"
+    })
+    .fromString(data)
+    .on("data",(d)=>{
+      const str=d.toString();
+      
+      assert.notEqual(str[str.length-2],",");
+    })
+    .on("end",()=>{
+      done();
+    })
+  })
+  it ("should not send json if needEmitAll is false",async function(){
+    const data=`a,b,c
+1,2,3
+4,5,6`
+    return csv({
+      needEmitAll:false
+    })
+    .fromString(data)
     .then((d)=>{
-      assert.equal(d.length,2);
-      assert.equal(d[0].sample_no,"12669");
+      assert(d.length===0);
     })
-    
-  });
+  })
+  it ("should convert null to null object",async function(){
+    const data=`a,b,c
+null,2,3
+4,5,6`
+    return csv({
+      nullObject:true
+    })
+    .fromString(data)
+    .then((d)=>{
+      assert.equal(d[0].a,null)
+    })
+  })
+  it ("should process period properly",async function(){
+    const data=`a..,b,c
+1,2,3
+4,5,6`
+    return csv({
+    })
+    .fromString(data)
+    .then((d)=>{
+      assert.equal(d[0]["a.."],1);
+      assert.equal(d[1]["a.."],4);
+    })
+  })
 });

v1/core/workerMgr.js

@@ -7,3 +7,2 @@ module.exports = workerMgr;
 function workerMgr() {
-  var spawn = require("child_process").spawn;
   var exports = {
@@ -10,0 +9,0 @@ initWorker: initWorker,

v2/Converter.d.ts

@@ -6,3 +6,3 @@ /// <reference types="node" />
 import CSVError from "./CSVError";
-export declare class Converter extends Transform implements PromiseLike<Array<any>> {
+export declare class Converter extends Transform implements PromiseLike<any[]> {
     options: TransformOptions;
@@ -9,0 +9,0 @@ preRawData(onRawData: PreRawDataCallback): Converter;

v2/Converter.js

@@ -39,6 +39,7 @@ "use strict";
             // console.log("BBB");
-            setTimeout(function () {
+            //wait for next cycle to emit the errors.
+            setImmediate(function () {
                 _this.result.processError(err);
                 _this.emit("done", err);
-            }, 0);
+            });
         });
@@ -45,0 +46,0 @@ _this.once("done", function () {

v2/Converter.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"Converter.js","sourceRoot":"","sources":["../src/Converter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Converter.js","sourceRoot":"","sources":["../src/Converter.ts"],"names":[],"mappings":"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"}

v2/index.js

@@ -6,4 +6,5 @@ "use strict";
 };
+helper["csv"] = helper;
 helper["Converter"] = Converter_1.Converter;
 module.exports = helper;
 //# sourceMappingURL=index.js.map

v2/index.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,yCAAwC;AAExC,IAAM,MAAM,GAAG,UAAU,KAA8B,EAAE,OAA0B;IACjF,OAAO,IAAI,qBAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACvC,CAAC,CAAA;AAED,MAAM,CAAC,WAAW,CAAC,GAAG,qBAAS,CAAC;AAChC,iBAAQ,MAAM,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,yCAAwC;AAExC,IAAM,MAAM,GAAG,UAAU,KAA8B,EAAE,OAA0B;IACjF,OAAO,IAAI,qBAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACvC,CAAC,CAAA;AACD,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;AACvB,MAAM,CAAC,WAAW,CAAC,GAAG,qBAAS,CAAC;AAChC,iBAAQ,MAAM,CAAC"}

v2/lineToJson.js

@@ -117,3 +117,12 @@ "use strict";
             if (head.indexOf(".") > -1) {
-                if (conv.parseParam.colParser[head] && conv.parseParam.colParser[head].flat) {
+                var headArr = head.split(".");
+                var jsonHead = true;
+                while (headArr.length > 0) {
+                    var headCom = headArr.shift();
+                    if (headCom.length === 0) {
+                        jsonHead = false;
+                        break;
+                    }
+                }
+                if (!jsonHead || conv.parseParam.colParser[head] && conv.parseParam.colParser[head].flat) {
                     conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;
@@ -130,2 +139,5 @@ }
     }
+    if (conv.parseParam.nullObject === true && value === "null") {
+        value = null;
+    }
     conv.parseRuntime.columnValueSetter[headIdx](resultJson, head, value);
@@ -132,0 +144,0 @@ // flatSetter(resultJson, head, value);

v2/lineToJson.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"lineToJson.js","sourceRoot":"","sources":["../src/lineToJson.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lineToJson.js","sourceRoot":"","sources":["../src/lineToJson.ts"],"names":[],"mappings":"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"}

v2/Parameters.d.ts

@@ -68,3 +68,3 @@ export interface CSVParseParam {
     /**
-     *  Always interpret each line (as defined by eol) as a row. This will prevent eol characters from being used within a row (even inside a quoted field). This ensures that misplaced quotes only break on row, and not all ensuing rows.
+     *  Always interpret each line (as defined by eol) as a row. This will prevent eol characters from being used within a row (even inside a quoted field). Default is false. Change to true if you are confident no inline line breaks (like line break in a cell which has multi line text)
      */
@@ -76,2 +76,14 @@ alwaysSplitAtEOL: boolean;
     output: "json" | "csv" | "line";
+    /**
+     * Convert string "null" to null object in JSON outputs. Default is false.
+     */
+    nullObject: boolean;
+    /**
+     * Define the format required by downstream (this parameter does not work if objectMode is on). `line` -- json is emitted in a single line separated by a line breake like "json1\njson2" . `array` -- downstream requires array format like "[json1,json2]". Default is line.
+     */
+    downstreamFormat: "line" | "array";
+    /**
+     * Define whether .then(callback) returns all JSON data in its callback. Default is true. Change to false to save memory if subscribing json lines.
+     */
+    needEmitAll: boolean;
 }
@@ -78,0 +90,0 @@ export declare type CellParser = (item: string, head: string, resultRow: any, row: string[], columnIndex: number) => any;

v2/Parameters.js

@@ -22,3 +22,6 @@ "use strict";
         alwaysSplitAtEOL: false,
-        output: "json"
+        output: "json",
+        nullObject: false,
+        downstreamFormat: "line",
+        needEmitAll: true
     };
@@ -25,0 +28,0 @@ if (!params) {

v2/Parameters.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"Parameters.js","sourceRoot":"","sources":["../src/Parameters.ts"],"names":[],"mappings":";;AAoFA,qBAA4B,MAA+B;IACzD,IAAM,YAAY,GAAkB;QAClC,SAAS,EAAE,GAAG;QACd,aAAa,EAAE,SAAS;QACxB,cAAc,EAAE,SAAS;QACzB,KAAK,EAAE,GAAG;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,KAAK;QAChB,WAAW,EAAE,KAAK;QAClB,eAAe;QACf,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,SAAS;QAClB,QAAQ,EAAE,KAAK;QACf,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,KAAK;QAClB,MAAM,EAAE,GAAG;QACX,SAAS,EAAE,EAAE;QACb,GAAG,EAAE,SAAS;QACd,gBAAgB,EAAE,KAAK;QACvB,MAAM,EAAE,MAAM;KACf,CAAA;IACD,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,GAAG,EAAE,CAAC;KACb;IACD,KAAK,IAAI,GAAG,IAAI,MAAM,EAAE;QACtB,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;YAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;gBAC9B,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aAC5C;iBAAM;gBACL,YAAY,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;aACjC;SACF;KACF;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AAlCD,kCAkCC"}
+{"version":3,"file":"Parameters.js","sourceRoot":"","sources":["../src/Parameters.ts"],"names":[],"mappings":";;AAiGA,qBAA4B,MAA+B;IACzD,IAAM,YAAY,GAAkB;QAClC,SAAS,EAAE,GAAG;QACd,aAAa,EAAE,SAAS;QACxB,cAAc,EAAE,SAAS;QACzB,KAAK,EAAE,GAAG;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,KAAK;QAChB,WAAW,EAAE,KAAK;QAClB,eAAe;QACf,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,SAAS;QAClB,QAAQ,EAAE,KAAK;QACf,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,KAAK;QAClB,MAAM,EAAE,GAAG;QACX,SAAS,EAAE,EAAE;QACb,GAAG,EAAE,SAAS;QACd,gBAAgB,EAAE,KAAK;QACvB,MAAM,EAAE,MAAM;QACd,UAAU,EAAE,KAAK;QACjB,gBAAgB,EAAC,MAAM;QACvB,WAAW,EAAC,IAAI;KACjB,CAAA;IACD,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,GAAG,EAAE,CAAC;KACb;IACD,KAAK,IAAI,GAAG,IAAI,MAAM,EAAE;QACtB,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;YAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;gBAC9B,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aAC5C;iBAAM;gBACL,YAAY,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;aACjC;SACF;KACF;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AArCD,kCAqCC"}

v2/Result.js

@@ -7,2 +7,3 @@ "use strict";
 var bluebird_1 = __importDefault(require("bluebird"));
+var os_1 = require("os");
 var Result = /** @class */ (function () {
@@ -32,3 +33,4 @@ function Result(converter) {
         get: function () {
-            return !!this.converter.parseRuntime.then;
+            return !!this.converter.parseRuntime.then && this.converter.parseParam.needEmitAll;
+            // return !!this.converter.parseRuntime.then;
         },
@@ -41,2 +43,7 @@ enumerable: true,
         var startPos = this.converter.parseRuntime.parsedLineNumber;
+        if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === "array") {
+            if (startPos === 0) {
+                pushDownstream(this.converter, "[" + os_1.EOL);
+            }
+        }
         // let prom: P<any>;
@@ -77,6 +84,9 @@ return new bluebird_1.default(function (resolve, reject) {
     Result.prototype.endProcess = function () {
-        if (this.needEmitAll) {
-            if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onfulfilled) {
+        if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onfulfilled) {
+            if (this.needEmitAll) {
                 this.converter.parseRuntime.then.onfulfilled(this.finalResult);
             }
+            else {
+                this.converter.parseRuntime.then.onfulfilled([]);
+            }
         }
@@ -86,2 +96,5 @@ if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onCompleted) {
         }
+        if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === "array") {
+            pushDownstream(this.converter, "]" + os_1.EOL);
+        }
     };
@@ -149,3 +162,4 @@ return Result;
     if (typeof res === "object" && !conv.options.objectMode) {
-        conv.push(JSON.stringify(res) + "\n", "utf8");
+        var data = JSON.stringify(res);
+        conv.push(data + (conv.parseParam.downstreamFormat === "array" ? "," + os_1.EOL : os_1.EOL), "utf8");
     }
@@ -152,0 +166,0 @@ else {

v2/Result.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"Result.js","sourceRoot":"","sources":["../src/Result.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Result.js","sourceRoot":"","sources":["../src/Result.ts"],"names":[],"mappings":"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"}

v2/rowSplit.js

@@ -82,7 +82,14 @@ "use strict";
                         var count = 0;
+                        var prev = "";
                         for (var _i = 0, e_1 = e; _i < e_1.length; _i++) {
                             var c = e_1[_i];
-                            if (c === quote) {
+                            // count quotes only if previous character is not escape char
+                            if (c === quote && prev !== this.escape) {
                                 count++;
+                                prev = "";
                             }
+                            else {
+                                // save previous char to temp variable
+                                prev = c;
+                            }
                         }
@@ -89,0 +96,0 @@ if (count % 2 === 1) {

v2/rowSplit.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"rowSplit.js","sourceRoot":"","sources":["../src/rowSplit.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rowSplit.js","sourceRoot":"","sources":["../src/rowSplit.ts"],"names":[],"mappings":";;;;;AAGA,oDAA8B;AAC9B,+BAA0D;AAE1D,IAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AACpD;IAaE,kBAAoB,IAAe;QAAf,SAAI,GAAJ,IAAI,CAAW;QAT3B,iBAAY,GAA8B,EAAE,CAAC;QAC7C,qBAAgB,GAAG,KAAK,CAAC;QACzB,uBAAkB,GAAa,SAAS,CAAC;QAQ/C,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;QACnC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;QACjC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;IACvC,CAAC;IAVD,sBAAY,uCAAiB;aAA7B;YACE,IAAI,IAAI,CAAC,kBAAkB,KAAK,SAAS,EAAE;gBACzC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;aACvE;YACD,OAAO,IAAI,CAAC,kBAAkB,CAAC;QACjC,CAAC;;;OAAA;IAMD,wBAAK,GAAL,UAAM,QAAkB;QACtB,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE;YAC/F,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;SACpC;QACD,IAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,YAAY,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,WAAW,EAAE,KAAK,MAAM,EAAE;YAClH,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;SAEhE;QACD,IAAI,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACpD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YAC9D,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;SAC9B;QACD,IAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QACnD,IAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACzC,IAAI,KAAK,KAAK,KAAK,EAAE;YACnB,IAAI,IAAI,EAAE;gBACR,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACtC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;iBAC9B;aACF;YACD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;SACxC;aAAM;YACL,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;SACtD;IAEH,CAAC;IACO,2BAAQ,GAAhB,UAAiB,MAAgB,EAAE,IAAa,EAAE,KAAa,EAAE,SAAiB;QAChF,IAAM,GAAG,GAAa,EAAE,CAAC;QACzB,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;YACvD,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YAClB,IAAI,CAAC,OAAO,IAAI,IAAI,EAAE;gBACpB,CAAC,GAAG,eAAQ,CAAC,CAAC,CAAC,CAAC;aACjB;YACD,IAAM,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC;YACrB,IAAI,CAAC,OAAO,EAAE;gBACZ,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE;oBAC9C,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;oBACb,SAAS;iBACV;qBAAM,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,YAAY;oBAC5C,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;oBAChB,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,aAAa;wBACvC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;wBACzC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;wBACxB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;wBACZ,SAAS;qBACV;yBAAM,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE;wBAClC,IAAI,KAAK,GAAG,CAAC,CAAC;wBACd,IAAI,IAAI,GAAG,EAAE,CAAC;wBACd,KAAgB,UAAC,EAAD,OAAC,EAAD,eAAC,EAAD,IAAC;4BAAZ,IAAM,CAAC,UAAA;4BACV,6DAA6D;4BAC7D,IAAI,CAAC,KAAK,KAAK,IAAI,IAAI,KAAK,IAAI,CAAC,MAAM,EAAE;gCACvC,KAAK,EAAE,CAAC;gCACR,IAAI,GAAG,EAAE,CAAC;6BACX;iCAAM;gCACL,sCAAsC;gCACtC,IAAI,GAAG,CAAC,CAAC;6BACV;yBACF;wBACD,IAAI,KAAK,GAAG,CAAC,KAAK,CAAC,EAAE;4BACnB,IAAI,IAAI,EAAE;gCACR,CAAC,GAAG,gBAAS,CAAC,CAAC,CAAC,CAAC;6BAClB;4BACD,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;4BACpB,SAAS;yBACV;6BAAI;4BACH,OAAO,GAAG,IAAI,CAAC;4BACf,SAAS,IAAI,CAAC,CAAC;4BACf,SAAS;yBACV;qBACF;yBACI;wBACH,OAAO,GAAG,IAAI,CAAC;wBACf,SAAS,IAAI,CAAC,CAAC;wBACf,SAAS;qBACV;iBACF;qBAAM;oBACL,IAAI,IAAI,EAAE;wBACR,CAAC,GAAG,gBAAS,CAAC,CAAC,CAAC,CAAC;qBAClB;oBACD,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBACZ,SAAS;iBACV;aACF;iBAAM,EAAE,2BAA2B;gBAClC,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,oBAAoB;oBAC9C,OAAO,GAAG,KAAK,CAAC;oBAChB,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;oBACzB,SAAS,IAAI,SAAS,GAAG,CAAC,CAAC;oBAC3B,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;oBACxC,IAAI,IAAI,EAAE;wBACR,SAAS,GAAG,gBAAS,CAAC,SAAS,CAAC,CAAC;qBAClC;oBACD,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBACpB,SAAS,GAAG,EAAE,CAAC;iBAChB;qBAAM;oBACL,SAAS,IAAI,SAAS,GAAG,CAAC,CAAC;iBAC5B;aACF;SACF;QAED,0CAA0C;QAC1C,iCAAiC;QACjC,IAAI;QAEJ,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC;IAC1C,CAAC;IACO,+BAAY,GAApB,UAAqB,QAAkB;QACrC,IAAI,OAAO,CAAC;QACZ,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,KAAK,MAAM,EAAE;YAC7C,OAAO,GAAG,gBAAgB,CAAC;SAC5B;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,YAAY,KAAK,EAAE;YAC1D,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;SAC1C;aAAM;YACL,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;SACvC;QACD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,GAAG,GAAG,GAAG,CAAC;QACd,OAAO,CAAC,OAAO,CAAC,UAAU,KAAK;YAC7B,IAAM,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;YAChD,IAAI,UAAU,GAAG,KAAK,EAAE;gBACtB,GAAG,GAAG,KAAK,CAAC;gBACZ,KAAK,GAAG,UAAU,CAAC;aACpB;QACH,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,CAAC;IACb,CAAC;IACO,8BAAW,GAAnB,UAAoB,GAAW;QAC7B,IAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,OAAO,GAAG,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CACzB,GAAG,CAAC,CAAC,CAAC,KAAK,KAAK;YAChB,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;IACjE,CAAC;IACO,+BAAY,GAApB,UAAqB,GAAW;QAC9B,IAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE;YAC7B,GAAG,GAAG,gBAAS,CAAC,GAAG,CAAC,CAAC;SACtB;QACD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,GAAG,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;QACzB,OAAO,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,MAAM,EAAE;YAChD,GAAG,EAAE,CAAC;YACN,KAAK,EAAE,CAAC;SACT;QACD,OAAO,KAAK,GAAG,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,gDAAgD;IAChD,4CAA4C;IAC5C,uBAAuB;IACvB,gEAAgE;IAChE,oEAAoE;IACpE,MAAM;IACN,gBAAgB;IAChB,IAAI;IAGI,8BAAW,GAAnB,UAAoB,OAAe;QACjC,IAAM,GAAG,GAAG,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC;QACnD,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;YACxC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,IAAI,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;SAClF;QACD,IAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACtC,+BAA+B;QAC/B,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IACD,kCAAe,GAAf,UAAgB,KAAiB;QAC/B,IAAM,QAAQ,GAAe,EAAE,CAAC;QAChC,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,OAAO,KAAK,CAAC,MAAM,EAAE;YACnB,IAAM,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;YAClC,IAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,GAAG,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE;gBAC9D,SAAS;aACV;YACD,IAAI,GAAG,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE;gBACvD,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE;oBAC1C,QAAQ,CAAC,IAAI,CAAC,kBAAW,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAC;iBAC/E;qBAAM;oBACL,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;iBAC1B;gBAED,IAAI,GAAG,EAAE,CAAC;aACX;iBAAM;gBACL,IAAI,GAAG,IAAI,GAAG,CAAC,gBAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,CAAC;aAC9D;SACF;QACD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAChD,CAAC;IACH,eAAC;AAAD,CAAC,AApND,IAoNC;AApNY,4BAAQ"}

.ts-node/46be5da21...782b06ed868641caf40c0e9d7ff16f490303.js

-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var src_1 = __importDefault(require("../src"));
-var assert = require("assert");
-var fs = require("fs");
-var sinon_1 = require("sinon");
-var sb = sinon_1.sandbox.create();
-describe("testCSVConverter3", function () {
-    afterEach(function () {
-        sb.restore();
-    });
-    it("should parse large csv file with UTF-8 without spliting characters", function (done) {
-        var testData = __dirname + "/data/large-utf8.csv";
-        var rs = fs.createReadStream(testData);
-        var csvConverter = src_1.default({});
-        var count = 0;
-        csvConverter.preRawData(function (csvRawData) {
-            assert(csvRawData.charCodeAt(0) < 2000);
-            return csvRawData;
-        });
-        csvConverter.on("data", function () {
-            count++;
-        });
-        csvConverter.then(function () {
-            assert(count === 5290);
-            done();
-        });
-        rs.pipe(csvConverter);
-    });
-    it("should setup customise type convert function", function (done) {
-        src_1.default({
-            checkType: true,
-            colParser: {
-                "column1": "string",
-                "column5": function (item, head, resultRow, row, i) {
-                    assert.equal(item, '{"hello":"world"}');
-                    assert.equal(head, "column5"),
-                        assert(resultRow);
-                    assert(row);
-                    assert.equal(i, 5);
-                    return "hello world";
-                }
-            }
-        })
-            .fromFile(__dirname + "/data/dataWithType")
-            .subscribe(function (json) {
-            assert.equal(typeof json.column1, "string");
-            assert.equal(json.column5, "hello world");
-            assert.strictEqual(json["name#!"], false);
-            assert.strictEqual(json["column9"], true);
-        })
-            .on('done', function () {
-            done();
-        });
-    });
-    it("should accept pipe as quote", function (done) {
-        src_1.default({
-            quote: "|",
-            output: "csv"
-        })
-            .fromFile(__dirname + "/data/pipeAsQuote")
-            .subscribe(function (csv) {
-            assert.equal(csv[2], "blahhh, blah");
-        })
-            .on('done', function () {
-            done();
-        });
-    });
-    it("emit file not exists error when try to open a non-exists file", function () {
-        var called = false;
-        var cb = sb.spy(function (err) {
-            assert(err.toString().indexOf("File does not exist") > -1);
-        });
-        return src_1.default()
-            .fromFile("somefile")
-            .subscribe(function (csv) {
-        })
-            .on("error", cb)
-            .then(function () {
-            assert(false);
-        }, function (err) {
-            assert.equal(cb.callCount, 1);
-        });
-    });
-    it("should include column that is both included and excluded", function () {
-        return src_1.default({
-            includeColumns: /b/,
-            ignoreColumns: /a|b/
-        })
-            .fromString("a,b,c\n1,2,3\n4,5,6")
-            .subscribe(function (d) {
-            assert(d.b);
-            assert(!d.a);
-        });
-    });
-    it("should allow async preLine hook", function () {
-        return src_1.default()
-            .preFileLine(function (line) {
-            return new Promise(function (resolve, reject) {
-                setTimeout(function () {
-                    resolve(line + "changed");
-                }, 20);
-            });
-        })
-            .fromString("a,b\n1,2")
-            .subscribe(function (d) {
-            assert(d.bchanged);
-            assert.equal(d.bchanged, "2changed");
-        });
-    });
-    it("should allow async subscribe function", function () {
-        return src_1.default({ trim: true })
-            .fromString("a,b,c\n    1,2,3\n    4,5,6")
-            .subscribe(function (d) {
-            return new Promise(function (resolve, reject) {
-                setTimeout(function () {
-                    d.a = 10;
-                    resolve();
-                }, 20);
-            });
-        })
-            .then(function (d) {
-            assert.equal(d[0].a, 10);
-            assert.equal(d[1].a, 10);
-        });
-    });
-    it("should propagate value to next then", function () {
-        return src_1.default({ trim: true })
-            .fromString("a,b,c\n  1,2,3\n  4,5,6")
-            .then(undefined, undefined)
-            .then(function (d) {
-            assert.equal(d.length, 2);
-            assert.equal(d[0].a, "1");
-        });
-    });
-    it("should propagate error to next then", function () {
-        return src_1.default({ trim: true })
-            .fromFile(__dirname + "/data/dataWithUnclosedQuotes")
-            .then(undefined, undefined)
-            .then(function () {
-            assert(false);
-        }, function (err) {
-            assert(err);
-            assert.equal(err.err, "unclosed_quote");
-        });
-    });
-    it("should fallback to text is number can not be parsed", function () {
-        return src_1.default({
-            colParser: {
-                "a": "number"
-            }
-        })
-            .fromString("a,b,c\n  1,2,3\n  fefe,5,6")
-            .then(function (d) {
-            assert.strictEqual(d[0].a, 1);
-            assert.equal(d[1].a, "fefe");
-        });
-    });
-    it("should omit a column", function () {
-        return src_1.default({
-            colParser: {
-                "a": "omit"
-            }
-        })
-            .fromString("a,b,c\n  1,2,3\n  fefe,5,6")
-            .then(function (d) {
-            assert.strictEqual(d[0].a, undefined);
-            assert.equal(d[1].a, undefined);
-        });
-    });
-    it("could turn off quote and should trim even quote is turned off", function () {
-        return src_1.default({
-            quote: "off",
-            trim: true
-        })
-            .fromString("a,b,c\n  \"1\",\"2\",\"3\"\n  \"fefe,5\",6")
-            .then(function (d) {
-            assert.equal(d[0].a, '"1"');
-            assert.equal(d[0].b, '"2"');
-            assert.equal(d[1].a, '"fefe');
-            assert.equal(d[1].b, '5"');
-        });
-    });
-    it("should allow ignoreEmpty with checkColumn", function () {
-        return src_1.default({
-            checkColumn: true,
-            ignoreEmpty: true
-        })
-            .fromString("date,altitude,airtime\n    2016-07-08,2000,23\n    \n    2016-07-09,3000,43")
-            .then(function (data) {
-        }, function (err) {
-            console.log(err);
-            assert(!err);
-        });
-    });
-    it("should allow quotes without content", function () {
-        var data = "a|^^|^b^";
-        return src_1.default({
-            delimiter: '|',
-            quote: '^',
-            noheader: true,
-        })
-            .fromString(data)
-            .then(function (jsonObj) {
-            assert.equal(jsonObj[0].field2, "");
-        });
-    });
-    it("should parse header with quotes correctly", function () {
-        var testData = __dirname + "/data/csvWithUnclosedHeader";
-        return src_1.default({
-            headers: ["exam_date", "sample_no", "status", "sample_type", "patient_id", "last_name", "first_name", "gender_of_patient", "patient_birth_date", "patient_note", "patient_department", "accession_number", "sample_site", "physician", "operator", "department", "note", "test_order_code", "draw_time", "approval_status", "approval_time", "report_layout", "patient_account_number", "none_1", "errors_detected_during_measurement", "age", "error_code_01", "weight", "error_code_02", "height", "error_code_03", "hcg_beta_p", "error_code_04", "troponin_i_p", "error_code_05", "ck_mb_p", "error_code_06", "d_dimer_p", "error_code_07", "hscrp_p", "error_code_08", "myoglobin_p", "error_code_09", "nt_probnp", "error_code_10", "crp", "error_code_11", "bnp", "error_code_12", "tnt", "error_code_13", "demo_p", "error_code_14", "pct", "error_code_15"]
-        })
-            .fromFile(testData)
-            .then(function (d) {
-            assert.equal(d.length, 2);
-            assert.equal(d[0].sample_no, "12669");
-        });
-    });
-});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/test/testCSVConverter3.ts","sources":["/Users/kxiang/work/projects/csv2json/test/testCSVConverter3.ts"],"names":[],"mappings":"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","sourcesContent":["import csv from \"../src\";\nvar assert = require(\"assert\");\nvar fs = require(\"fs\");\nimport { sandbox } from \"sinon\";\nimport CSVError from \"../src/CSVError\";\nconst sb = sandbox.create();\ndescribe(\"testCSVConverter3\", function () {\n  afterEach(function () {\n    sb.restore();\n  });\n  it(\"should parse large csv file with UTF-8 without spliting characters\", function (done) {\n    var testData = __dirname + \"/data/large-utf8.csv\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = csv({\n    });\n    var count = 0;\n    csvConverter.preRawData(function (csvRawData) {\n      assert(csvRawData.charCodeAt(0) < 2000);\n      return csvRawData;\n    })\n    csvConverter.on(\"data\", function () {\n      count++;\n    });\n    csvConverter.then(function () {\n      assert(count === 5290);\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n  it(\"should setup customise type convert function\", function (done) {\n    csv({\n      checkType: true,\n      colParser: {\n        \"column1\": \"string\",\n        \"column5\": function (item, head, resultRow, row, i) {\n          assert.equal(item, '{\"hello\":\"world\"}');\n          assert.equal(head, \"column5\"),\n            assert(resultRow);\n          assert(row);\n          assert.equal(i, 5);\n          return \"hello world\";\n        }\n      }\n    })\n      .fromFile(__dirname + \"/data/dataWithType\")\n      .subscribe(function (json) {\n        assert.equal(typeof json.column1, \"string\");\n        assert.equal(json.column5, \"hello world\");\n        assert.strictEqual(json[\"name#!\"], false);\n        assert.strictEqual(json[\"column9\"], true);\n      })\n      .on('done', function () {\n        done()\n      });\n  })\n  it(\"should accept pipe as quote\", function (done) {\n    csv({\n      quote: \"|\",\n      output: \"csv\"\n    })\n      .fromFile(__dirname + \"/data/pipeAsQuote\")\n      .subscribe(function (csv) {\n        assert.equal(csv[2], \"blahhh, blah\");\n      })\n      .on('done', function () {\n        done()\n      });\n  })\n  it(\"emit file not exists error when try to open a non-exists file\", function () {\n    let called = false;\n    const cb = sb.spy((err) => {\n      assert(err.toString().indexOf(\"File does not exist\") > -1);\n    });\n    return csv()\n      .fromFile(\"somefile\")\n      .subscribe(function (csv) {\n\n      })\n      .on(\"error\", cb)\n      .then(() => {\n        assert(false);\n      }, (err) => {\n        assert.equal(cb.callCount, 1);\n      })\n\n  })\n  it(\"should include column that is both included and excluded\", () => {\n    return csv({\n      includeColumns: /b/,\n      ignoreColumns: /a|b/\n    })\n      .fromString(`a,b,c\n1,2,3\n4,5,6`)\n      .subscribe((d) => {\n        assert(d.b);\n        assert(!d.a);\n      })\n  })\n  it(\"should allow async preLine hook\", () => {\n    return csv()\n      .preFileLine((line) => {\n        return new Promise((resolve, reject) => {\n          setTimeout(() => {\n            resolve(line + \"changed\")\n          }, 20);\n\n        })\n      })\n      .fromString(`a,b\n1,2`)\n      .subscribe((d) => {\n        assert(d.bchanged);\n        assert.equal(d.bchanged, \"2changed\");\n      })\n\n  })\n\n  it(\"should allow async subscribe function\", () => {\n    return csv({ trim: true })\n      .fromString(`a,b,c\n    1,2,3\n    4,5,6`)\n      .subscribe((d) => {\n        return new Promise((resolve, reject) => {\n          setTimeout(() => {\n            d.a = 10;\n            resolve();\n          }, 20);\n        })\n      })\n      .then((d) => {\n        assert.equal(d[0].a, 10);\n        assert.equal(d[1].a, 10);\n      })\n  })\n  it(\"should propagate value to next then\", () => {\n    return csv({ trim: true })\n      .fromString(`a,b,c\n  1,2,3\n  4,5,6`)\n      .then(undefined, undefined)\n      .then((d) => {\n        assert.equal(d.length, 2);\n        assert.equal(d[0].a, \"1\");\n      })\n\n  })\n  it(\"should propagate error to next then\", () => {\n    return csv({ trim: true })\n      .fromFile(__dirname + \"/data/dataWithUnclosedQuotes\")\n      .then(undefined, undefined)\n      .then(() => {\n        assert(false)\n      }, (err: CSVError) => {\n        assert(err);\n        assert.equal(err.err, \"unclosed_quote\");\n      })\n  })\n  it(\"should fallback to text is number can not be parsed\", () => {\n    return csv({\n      colParser: {\n        \"a\": \"number\"\n      }\n    })\n      .fromString(`a,b,c\n  1,2,3\n  fefe,5,6`)\n      .then((d) => {\n        assert.strictEqual(d[0].a, 1);\n        assert.equal(d[1].a, \"fefe\");\n      })\n  })\n  it(\"should omit a column\", () => {\n    return csv({\n      colParser: {\n        \"a\": \"omit\"\n      }\n    })\n      .fromString(`a,b,c\n  1,2,3\n  fefe,5,6`)\n      .then((d) => {\n        assert.strictEqual(d[0].a, undefined);\n        assert.equal(d[1].a, undefined);\n      })\n  })\n  it(\"could turn off quote and should trim even quote is turned off\", () => {\n    return csv({\n      quote: \"off\",\n      trim: true\n    })\n      .fromString(`a,b,c\n  \"1\",\"2\",\"3\"\n  \"fefe,5\",6`)\n      .then((d) => {\n        assert.equal(d[0].a, '\"1\"');\n        assert.equal(d[0].b, '\"2\"');\n        assert.equal(d[1].a, '\"fefe');\n        assert.equal(d[1].b, '5\"');\n      })\n  })\n  it(\"should allow ignoreEmpty with checkColumn\", () => {\n    return csv({\n      checkColumn: true,\n      ignoreEmpty: true\n    })\n      .fromString(`date,altitude,airtime\n    2016-07-08,2000,23\n    \n    2016-07-09,3000,43`)\n      .then((data) => {\n\n      }, (err) => {\n        console.log(err);\n        assert(!err);\n      })\n  });\n  it(\"should allow quotes without content\", () => {\n    const data = \"a|^^|^b^\";\n    return csv({\n      delimiter: '|',\n      quote: '^',\n      noheader: true,\n    })\n      .fromString(data)\n      .then((jsonObj) => {\n        assert.equal(jsonObj[0].field2, \"\");\n      });\n  })\n  it(\"should parse header with quotes correctly\", function () {\n    var testData = __dirname + \"/data/csvWithUnclosedHeader\";\n    return csv({\n      headers:[\"exam_date\",\"sample_no\",\"status\",\"sample_type\",\"patient_id\",\"last_name\",\"first_name\",\"gender_of_patient\",\"patient_birth_date\",\"patient_note\",\"patient_department\",\"accession_number\",\"sample_site\",\"physician\",\"operator\",\"department\",\"note\",\"test_order_code\",\"draw_time\",\"approval_status\",\"approval_time\",\"report_layout\",\"patient_account_number\",\"none_1\",\"errors_detected_during_measurement\",\"age\",\"error_code_01\",\"weight\",\"error_code_02\",\"height\",\"error_code_03\",\"hcg_beta_p\",\"error_code_04\",\"troponin_i_p\",\"error_code_05\",\"ck_mb_p\",\"error_code_06\",\"d_dimer_p\",\"error_code_07\",\"hscrp_p\",\"error_code_08\",\"myoglobin_p\",\"error_code_09\",\"nt_probnp\",\"error_code_10\",\"crp\",\"error_code_11\",\"bnp\",\"error_code_12\",\"tnt\",\"error_code_13\",\"demo_p\",\"error_code_14\",\"pct\",\"error_code_15\"]\n    })\n    .fromFile(testData)\n    .then((d)=>{\n      assert.equal(d.length,2);\n      assert.equal(d[0].sample_no,\"12669\");\n    })\n    \n  });\n});\n"]}

.ts-node/46be5da21...a3a4ade71c6ecc7e2cdcec534c76e6d23de3.js

-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var bluebird_1 = __importDefault(require("bluebird"));
-var Result = /** @class */ (function () {
-    function Result(converter) {
-        this.converter = converter;
-        this.finalResult = [];
-    }
-    Object.defineProperty(Result.prototype, "needEmitLine", {
-        get: function () {
-            return !!this.converter.parseRuntime.subscribe && !!this.converter.parseRuntime.subscribe.onNext || this.needPushDownstream;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Result.prototype, "needPushDownstream", {
-        get: function () {
-            if (this._needPushDownstream === undefined) {
-                this._needPushDownstream = this.converter.listeners("data").length > 0 || this.converter.listeners("readable").length > 0;
-            }
-            return this._needPushDownstream;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Result.prototype, "needEmitAll", {
-        get: function () {
-            return !!this.converter.parseRuntime.then;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Result.prototype.processResult = function (resultLines) {
-        var _this = this;
-        var startPos = this.converter.parseRuntime.parsedLineNumber;
-        // let prom: P<any>;
-        return new bluebird_1.default(function (resolve, reject) {
-            if (_this.needEmitLine) {
-                processLineByLine(resultLines, _this.converter, 0, _this.needPushDownstream, function (err) {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        _this.appendFinalResult(resultLines);
-                        resolve();
-                    }
-                });
-                // resolve();
-            }
-            else {
-                _this.appendFinalResult(resultLines);
-                resolve();
-            }
-        });
-    };
-    Result.prototype.appendFinalResult = function (lines) {
-        if (this.needEmitAll) {
-            this.finalResult = this.finalResult.concat(lines);
-        }
-        this.converter.parseRuntime.parsedLineNumber += lines.length;
-    };
-    Result.prototype.processError = function (err) {
-        if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onError) {
-            this.converter.parseRuntime.subscribe.onError(err);
-        }
-        if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onrejected) {
-            this.converter.parseRuntime.then.onrejected(err);
-        }
-    };
-    Result.prototype.endProcess = function () {
-        if (this.needEmitAll) {
-            if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onfulfilled) {
-                this.converter.parseRuntime.then.onfulfilled(this.finalResult);
-            }
-        }
-        if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onCompleted) {
-            this.converter.parseRuntime.subscribe.onCompleted();
-        }
-    };
-    return Result;
-}());
-exports.Result = Result;
-function processLineByLine(lines, conv, offset, needPushDownstream, cb) {
-    if (offset >= lines.length) {
-        cb();
-    }
-    else {
-        if (conv.parseRuntime.subscribe && conv.parseRuntime.subscribe.onNext) {
-            var hook_1 = conv.parseRuntime.subscribe.onNext;
-            var nextLine_1 = lines[offset];
-            var res = hook_1(nextLine_1, conv.parseRuntime.parsedLineNumber + offset);
-            offset++;
-            // if (isAsync === undefined) {
-            if (res && res.then) {
-                res.then(function () {
-                    processRecursive(lines, hook_1, conv, offset, needPushDownstream, cb, nextLine_1);
-                }, cb);
-            }
-            else {
-                // processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);
-                if (needPushDownstream) {
-                    pushDownstream(conv, nextLine_1);
-                }
-                while (offset < lines.length) {
-                    var line = lines[offset];
-                    hook_1(line, conv.parseRuntime.parsedLineNumber + offset);
-                    offset++;
-                    if (needPushDownstream) {
-                        pushDownstream(conv, line);
-                    }
-                }
-                cb();
-            }
-            // } else if (isAsync === true) {
-            //   (res as PromiseLike<void>).then(function () {
-            //     processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, true);
-            //   }, cb);
-            // } else if (isAsync === false) {
-            //   processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);
-            // }
-        }
-        else {
-            if (needPushDownstream) {
-                while (offset < lines.length) {
-                    var line = lines[offset++];
-                    pushDownstream(conv, line);
-                }
-            }
-            cb();
-        }
-    }
-}
-function processRecursive(lines, hook, conv, offset, needPushDownstream, cb, res) {
-    if (needPushDownstream) {
-        pushDownstream(conv, res);
-    }
-    processLineByLine(lines, conv, offset, needPushDownstream, cb);
-}
-function pushDownstream(conv, res) {
-    if (typeof res === "object" && !conv.options.objectMode) {
-        conv.push(JSON.stringify(res) + "\n", "utf8");
-    }
-    else {
-        conv.push(res);
-    }
-}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/Result.ts","sources":["/Users/kxiang/work/projects/csv2json/src/Result.ts"],"names":[],"mappings":"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","sourcesContent":["import { Converter } from \"./Converter\";\nimport { ProcessLineResult } from \"./Processor\";\nimport P from \"bluebird\";\nimport CSVError from \"./CSVError\";\n\nexport class Result {\n  private get needEmitLine(): boolean {\n    return !!this.converter.parseRuntime.subscribe && !!this.converter.parseRuntime.subscribe.onNext || this.needPushDownstream\n  }\n  private _needPushDownstream?: boolean;\n  private get needPushDownstream(): boolean {\n    if (this._needPushDownstream === undefined) {\n      this._needPushDownstream = this.converter.listeners(\"data\").length > 0 || this.converter.listeners(\"readable\").length > 0;\n    }\n    return this._needPushDownstream;\n  }\n  private get needEmitAll(): boolean {\n    return !!this.converter.parseRuntime.then;\n  }\n  private finalResult: any[] = [];\n  constructor(private converter: Converter) { }\n  processResult(resultLines: ProcessLineResult[]): P<any> {\n    const startPos = this.converter.parseRuntime.parsedLineNumber;\n    // let prom: P<any>;\n    return new P((resolve, reject) => {\n      if (this.needEmitLine) {\n        processLineByLine(\n          resultLines,\n          this.converter,\n          0,\n          this.needPushDownstream,\n          (err) => {\n            if (err) {\n              reject(err);\n            } else {\n              this.appendFinalResult(resultLines);\n              resolve();\n            }\n          },\n        )\n        // resolve();\n      } else {\n        this.appendFinalResult(resultLines);\n        resolve();\n      }\n    })\n  }\n  appendFinalResult(lines: any[]) {\n    if (this.needEmitAll) {\n      this.finalResult = this.finalResult.concat(lines);\n    }\n    this.converter.parseRuntime.parsedLineNumber += lines.length;\n  }\n  processError(err: CSVError) {\n    if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onError) {\n      this.converter.parseRuntime.subscribe.onError(err);\n    }\n    if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onrejected) {\n      this.converter.parseRuntime.then.onrejected(err);\n    }\n  }\n  endProcess() {\n    if (this.needEmitAll) {\n      if (this.converter.parseRuntime.then && this.converter.parseRuntime.then.onfulfilled) {\n        this.converter.parseRuntime.then.onfulfilled(this.finalResult);\n      }\n    }\n    if (this.converter.parseRuntime.subscribe && this.converter.parseRuntime.subscribe.onCompleted) {\n      this.converter.parseRuntime.subscribe.onCompleted();\n    }\n  }\n}\n\nfunction processLineByLine(\n  lines: ProcessLineResult[],\n\n  conv: Converter,\n  offset: number,\n  needPushDownstream: boolean,\n  cb: (err?) => void,\n) {\n  if (offset >= lines.length) {\n    cb();\n  } else {\n    if (conv.parseRuntime.subscribe && conv.parseRuntime.subscribe.onNext) {\n      const hook = conv.parseRuntime.subscribe.onNext;\n      const nextLine = lines[offset];\n      const res = hook(nextLine, conv.parseRuntime.parsedLineNumber + offset);\n      offset++;\n      // if (isAsync === undefined) {\n      if (res && res.then) {\n        res.then(function () {\n          processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine);\n        }, cb);\n      } else {\n        // processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);\n        if (needPushDownstream){\n          pushDownstream(conv,nextLine);\n        }\n        while (offset<lines.length){\n          const line=lines[offset];\n          hook(line, conv.parseRuntime.parsedLineNumber + offset);\n          offset++;\n          if (needPushDownstream){\n            pushDownstream(conv,line);\n          }\n        }\n        cb();\n      }\n      // } else if (isAsync === true) {\n      //   (res as PromiseLike<void>).then(function () {\n      //     processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, true);\n      //   }, cb);\n      // } else if (isAsync === false) {\n      //   processRecursive(lines, hook, conv, offset, needPushDownstream, cb, nextLine, false);\n      // }\n    } else {\n      if (needPushDownstream) {\n        while (offset<lines.length) {\n          const line = lines[offset++];\n          pushDownstream(conv, line);\n        }\n        \n      }\n      cb();\n    }\n\n  }\n}\n\nfunction processRecursive(\n  lines: ProcessLineResult[],\n  hook: (data: any, lineNumber: number) => void | PromiseLike<void>,\n  conv: Converter,\n  offset: number,\n  needPushDownstream: boolean,\n  cb: (err?) => void,\n  res: ProcessLineResult,\n) {\n  if (needPushDownstream) {\n    pushDownstream(conv, res);\n  }\n  processLineByLine(lines, conv, offset, needPushDownstream, cb);\n}\nfunction pushDownstream(conv: Converter, res: ProcessLineResult) {\n  if (typeof res === \"object\" && !conv.options.objectMode) {\n    conv.push(JSON.stringify(res) + \"\\n\", \"utf8\");\n  } else {\n    conv.push(res);\n  }\n}"]}

.ts-node/46be5da21...1828a2caaa54a764fc152183ad640d1d66be.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function initParseRuntime(converter) {
-    var params = converter.parseParam;
-    var rtn = {
-        needProcessIgnoreColumn: false,
-        needProcessIncludeColumn: false,
-        selectedColumns: undefined,
-        ended: false,
-        hasError: false,
-        error: undefined,
-        delimiter: converter.parseParam.delimiter,
-        eol: converter.parseParam.eol,
-        columnConv: [],
-        headerType: [],
-        headerTitle: [],
-        headerFlag: [],
-        headers: undefined,
-        started: false,
-        parsedLineNumber: 0,
-        columnValueSetter: [],
-    };
-    if (params.ignoreColumns) {
-        rtn.needProcessIgnoreColumn = true;
-    }
-    if (params.includeColumns) {
-        rtn.needProcessIncludeColumn = true;
-    }
-    return rtn;
-}
-exports.initParseRuntime = initParseRuntime;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/46be5da21...ac032beb92732a7fc3a93a7da308df59074b.js

-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var Processor_1 = require("./Processor");
-var bluebird_1 = __importDefault(require("bluebird"));
-var dataClean_1 = require("./dataClean");
-var getEol_1 = __importDefault(require("./getEol"));
-var fileline_1 = require("./fileline");
-var util_1 = require("./util");
-var rowSplit_1 = require("./rowSplit");
-var lineToJson_1 = __importDefault(require("./lineToJson"));
-var CSVError_1 = __importDefault(require("./CSVError"));
-var ProcessorLocal = /** @class */ (function (_super) {
-    __extends(ProcessorLocal, _super);
-    function ProcessorLocal() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.rowSplit = new rowSplit_1.RowSplit(_this.converter);
-        _this.eolEmitted = false;
-        _this._needEmitEol = undefined;
-        _this.headEmitted = false;
-        _this._needEmitHead = undefined;
-        return _this;
-    }
-    ProcessorLocal.prototype.flush = function () {
-        var _this = this;
-        if (this.runtime.csvLineBuffer && this.runtime.csvLineBuffer.length > 0) {
-            var buf = this.runtime.csvLineBuffer;
-            this.runtime.csvLineBuffer = undefined;
-            return this.process(buf, true)
-                .then(function (res) {
-                if (_this.runtime.csvLineBuffer && _this.runtime.csvLineBuffer.length > 0) {
-                    return bluebird_1.default.reject(CSVError_1.default.unclosed_quote(_this.runtime.parsedLineNumber, _this.runtime.csvLineBuffer.toString()));
-                }
-                else {
-                    return bluebird_1.default.resolve(res);
-                }
-            });
-        }
-        else {
-            return bluebird_1.default.resolve([]);
-        }
-    };
-    ProcessorLocal.prototype.destroy = function () {
-        return bluebird_1.default.resolve();
-    };
-    Object.defineProperty(ProcessorLocal.prototype, "needEmitEol", {
-        get: function () {
-            if (this._needEmitEol === undefined) {
-                this._needEmitEol = this.converter.listeners("eol").length > 0;
-            }
-            return this._needEmitEol;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ProcessorLocal.prototype, "needEmitHead", {
-        get: function () {
-            if (this._needEmitHead === undefined) {
-                this._needEmitHead = this.converter.listeners("header").length > 0;
-            }
-            return this._needEmitHead;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    ProcessorLocal.prototype.process = function (chunk, finalChunk) {
-        var _this = this;
-        if (finalChunk === void 0) { finalChunk = false; }
-        var csvString;
-        if (finalChunk) {
-            csvString = chunk.toString();
-        }
-        else {
-            csvString = dataClean_1.prepareData(chunk, this.converter.parseRuntime);
-        }
-        return bluebird_1.default.resolve()
-            .then(function () {
-            if (_this.runtime.preRawDataHook) {
-                return _this.runtime.preRawDataHook(csvString);
-            }
-            else {
-                return csvString;
-            }
-        })
-            .then(function (csv) {
-            if (csv && csv.length > 0) {
-                return _this.processCSV(csv, finalChunk);
-            }
-            else {
-                return bluebird_1.default.resolve([]);
-            }
-        });
-    };
-    ProcessorLocal.prototype.processCSV = function (csv, finalChunk) {
-        var _this = this;
-        var params = this.params;
-        var runtime = this.runtime;
-        if (!runtime.eol) {
-            getEol_1.default(csv, runtime);
-        }
-        if (this.needEmitEol && !this.eolEmitted && runtime.eol) {
-            this.converter.emit("eol", runtime.eol);
-            this.eolEmitted = true;
-        }
-        // trim csv file has initial blank lines.
-        if (params.ignoreEmpty && !runtime.started) {
-            csv = util_1.trimLeft(csv);
-        }
-        var stringToLineResult = fileline_1.stringToLines(csv, runtime);
-        if (!finalChunk) {
-            this.prependLeftBuf(util_1.bufFromString(stringToLineResult.partial));
-        }
-        else {
-            stringToLineResult.lines.push(stringToLineResult.partial);
-            stringToLineResult.partial = "";
-        }
-        if (stringToLineResult.lines.length > 0) {
-            var prom = void 0;
-            if (runtime.preFileLineHook) {
-                prom = this.runPreLineHook(stringToLineResult.lines);
-            }
-            else {
-                prom = bluebird_1.default.resolve(stringToLineResult.lines);
-            }
-            return prom.then(function (lines) {
-                if (!runtime.started
-                    && !_this.runtime.headers) {
-                    return _this.processDataWithHead(lines);
-                }
-                else {
-                    return _this.processCSVBody(lines);
-                }
-            });
-        }
-        else {
-            return bluebird_1.default.resolve([]);
-        }
-    };
-    ProcessorLocal.prototype.processDataWithHead = function (lines) {
-        if (this.params.noheader) {
-            if (this.params.headers) {
-                this.runtime.headers = this.params.headers;
-            }
-            else {
-                this.runtime.headers = [];
-            }
-        }
-        else {
-            var left = "";
-            var headerRow = [];
-            while (lines.length) {
-                var line = left + lines.shift();
-                var row = this.rowSplit.parse(line);
-                if (row.closed) {
-                    headerRow = row.cells;
-                    left = "";
-                    break;
-                }
-                else {
-                    left = line + getEol_1.default(line, this.runtime);
-                }
-            }
-            this.prependLeftBuf(util_1.bufFromString(left));
-            if (headerRow.length === 0) {
-                return [];
-            }
-            if (this.params.headers) {
-                this.runtime.headers = this.params.headers;
-            }
-            else {
-                this.runtime.headers = headerRow;
-            }
-        }
-        if (this.runtime.needProcessIgnoreColumn || this.runtime.needProcessIncludeColumn) {
-            this.filterHeader();
-        }
-        if (this.needEmitHead && !this.headEmitted) {
-            this.converter.emit("header", this.runtime.headers);
-            this.headEmitted = true;
-        }
-        return this.processCSVBody(lines);
-    };
-    ProcessorLocal.prototype.filterHeader = function () {
-        this.runtime.selectedColumns = [];
-        if (this.runtime.headers) {
-            var headers = this.runtime.headers;
-            for (var i = 0; i < headers.length; i++) {
-                if (this.params.ignoreColumns) {
-                    if (this.params.ignoreColumns.test(headers[i])) {
-                        if (this.params.includeColumns && this.params.includeColumns.test(headers[i])) {
-                            this.runtime.selectedColumns.push(i);
-                        }
-                        else {
-                            continue;
-                        }
-                    }
-                    else {
-                        this.runtime.selectedColumns.push(i);
-                    }
-                }
-                else if (this.params.includeColumns) {
-                    if (this.params.includeColumns.test(headers[i])) {
-                        this.runtime.selectedColumns.push(i);
-                    }
-                }
-                else {
-                    this.runtime.selectedColumns.push(i);
-                }
-                // if (this.params.includeColumns && this.params.includeColumns.test(headers[i])){
-                //   this.runtime.selectedColumns.push(i);
-                // }else{
-                //   if (this.params.ignoreColumns && this.params.ignoreColumns.test(headers[i])){
-                //     continue;
-                //   }else{
-                //     if (this.params.ignoreColumns && !this.params.includeColumns){
-                //       this.runtime.selectedColumns.push(i);
-                //     }
-                //   }
-                // }
-            }
-            this.runtime.headers = util_1.filterArray(this.runtime.headers, this.runtime.selectedColumns);
-        }
-    };
-    ProcessorLocal.prototype.processCSVBody = function (lines) {
-        if (this.params.output === "line") {
-            return lines;
-        }
-        else {
-            var result = this.rowSplit.parseMultiLines(lines);
-            this.prependLeftBuf(util_1.bufFromString(result.partial));
-            if (this.params.output === "csv") {
-                return result.rowsCells;
-            }
-            else {
-                return lineToJson_1.default(result.rowsCells, this.converter);
-            }
-        }
-        // var jsonArr = linesToJson(lines.lines, params, this.recordNum);
-        // this.processResult(jsonArr);
-        // this.lastIndex += jsonArr.length;
-        // this.recordNum += jsonArr.length;
-    };
-    ProcessorLocal.prototype.prependLeftBuf = function (buf) {
-        if (buf) {
-            if (this.runtime.csvLineBuffer) {
-                this.runtime.csvLineBuffer = Buffer.concat([buf, this.runtime.csvLineBuffer]);
-            }
-            else {
-                this.runtime.csvLineBuffer = buf;
-            }
-        }
-    };
-    ProcessorLocal.prototype.runPreLineHook = function (lines) {
-        var _this = this;
-        return new bluebird_1.default(function (resolve, reject) {
-            processLineHook(lines, _this.runtime, 0, function (err) {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(lines);
-                }
-            });
-        });
-    };
-    return ProcessorLocal;
-}(Processor_1.Processor));
-exports.ProcessorLocal = ProcessorLocal;
-function processLineHook(lines, runtime, offset, cb) {
-    if (offset >= lines.length) {
-        cb();
-    }
-    else {
-        if (runtime.preFileLineHook) {
-            var line = lines[offset];
-            var res = runtime.preFileLineHook(line, runtime.parsedLineNumber + offset);
-            offset++;
-            if (res && res.then) {
-                res.then(function (value) {
-                    lines[offset - 1] = value;
-                    processLineHook(lines, runtime, offset, cb);
-                });
-            }
-            else {
-                lines[offset - 1] = res;
-                while (offset < lines.length) {
-                    lines[offset] = runtime.preFileLineHook(lines[offset], runtime.parsedLineNumber + offset);
-                    offset++;
-                }
-                cb();
-            }
-        }
-        else {
-            cb();
-        }
-    }
-}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/ProcessorLocal.ts","sources":["/Users/kxiang/work/projects/csv2json/src/ProcessorLocal.ts"],"names":[],"mappings":"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","sourcesContent":["import { Processor, ProcessLineResult } from \"./Processor\";\nimport P from \"bluebird\";\nimport { prepareData } from \"./dataClean\";\nimport getEol from \"./getEol\";\nimport { stringToLines } from \"./fileline\";\nimport { bufFromString, filterArray,trimLeft } from \"./util\";\nimport { RowSplit } from \"./rowSplit\";\nimport lineToJson from \"./lineToJson\";\nimport { ParseRuntime } from \"./ParseRuntime\";\nimport CSVError from \"./CSVError\";\n\n\n\nexport class ProcessorLocal extends Processor {\n  flush(): P<ProcessLineResult[]> {\n    if (this.runtime.csvLineBuffer && this.runtime.csvLineBuffer.length > 0) {\n      const buf = this.runtime.csvLineBuffer;\n      this.runtime.csvLineBuffer = undefined;\n      return this.process(buf, true)\n        .then((res) => {\n          if (this.runtime.csvLineBuffer && this.runtime.csvLineBuffer.length > 0) {\n            return P.reject(CSVError.unclosed_quote(this.runtime.parsedLineNumber, this.runtime.csvLineBuffer.toString()))\n          } else {\n            return P.resolve(res);\n          }\n        })\n    } else {\n      return P.resolve([]);\n    }\n  }\n  destroy(): P<void> {\n    return P.resolve();\n  }\n  private rowSplit: RowSplit = new RowSplit(this.converter);\n  private eolEmitted = false;\n  private _needEmitEol?: boolean = undefined;\n  private get needEmitEol() {\n    if (this._needEmitEol === undefined) {\n      this._needEmitEol = this.converter.listeners(\"eol\").length > 0;\n    }\n    return this._needEmitEol;\n  }\n  private headEmitted = false;\n  private _needEmitHead?: boolean = undefined;\n  private get needEmitHead() {\n    if (this._needEmitHead === undefined) {\n      this._needEmitHead = this.converter.listeners(\"header\").length > 0;\n    }\n    return this._needEmitHead;\n\n  }\n  process(chunk: Buffer, finalChunk = false): P<ProcessLineResult[]> {\n    let csvString: string;\n    if (finalChunk) {\n      csvString = chunk.toString();\n    } else {\n      csvString = prepareData(chunk, this.converter.parseRuntime);\n\n    }\n    return P.resolve()\n      .then(() => {\n        if (this.runtime.preRawDataHook) {\n          return this.runtime.preRawDataHook(csvString);\n        } else {\n          return csvString;\n        }\n      })\n      .then((csv) => {\n        if (csv && csv.length > 0) {\n          return this.processCSV(csv, finalChunk);\n        } else {\n          return P.resolve([]);\n        }\n      })\n  }\n  private processCSV(csv: string, finalChunk: boolean): P<ProcessLineResult[]> {\n    const params = this.params;\n    const runtime = this.runtime;\n    if (!runtime.eol) {\n      getEol(csv, runtime);\n    }\n    if (this.needEmitEol && !this.eolEmitted && runtime.eol) {\n      this.converter.emit(\"eol\", runtime.eol);\n      this.eolEmitted = true;\n    }\n    // trim csv file has initial blank lines.\n    if (params.ignoreEmpty && !runtime.started) {\n      csv = trimLeft(csv);\n    }\n    const stringToLineResult = stringToLines(csv, runtime);\n    if (!finalChunk) {\n      this.prependLeftBuf(bufFromString(stringToLineResult.partial));\n    } else {\n      stringToLineResult.lines.push(stringToLineResult.partial);\n      stringToLineResult.partial = \"\";\n    }\n    if (stringToLineResult.lines.length > 0) {\n      let prom: P<string[]>;\n      if (runtime.preFileLineHook) {\n        prom = this.runPreLineHook(stringToLineResult.lines);\n      } else {\n        prom = P.resolve(stringToLineResult.lines);\n      }\n      return prom.then((lines) => {\n        if (!runtime.started\n          && !this.runtime.headers\n        ) {\n          return this.processDataWithHead(lines);\n        } else {\n          return this.processCSVBody(lines);\n        }\n\n      })\n\n    } else {\n\n      return P.resolve([]);\n    }\n\n  }\n  private processDataWithHead(lines: string[]): ProcessLineResult[] {\n    if (this.params.noheader) {\n      if (this.params.headers) {\n        this.runtime.headers = this.params.headers;\n      } else {\n        this.runtime.headers = [];\n      }\n    } else {\n      let left = \"\";\n      let headerRow: string[] = [];\n      while (lines.length) {\n        const line = left + lines.shift();\n        const row = this.rowSplit.parse(line);\n        if (row.closed) {\n          headerRow = row.cells;\n          left = \"\";\n          break;\n        } else {\n          left = line + getEol(line, this.runtime);\n        }\n      }\n      this.prependLeftBuf(bufFromString(left));\n\n      if (headerRow.length === 0) {\n        return [];\n      }\n      if (this.params.headers) {\n        this.runtime.headers = this.params.headers;\n      } else {\n        this.runtime.headers = headerRow;\n      }\n    }\n    if (this.runtime.needProcessIgnoreColumn || this.runtime.needProcessIncludeColumn) {\n      this.filterHeader();\n    }\n    if (this.needEmitHead && !this.headEmitted) {\n      this.converter.emit(\"header\", this.runtime.headers);\n      this.headEmitted = true;\n    }\n    return this.processCSVBody(lines);\n  }\n  private filterHeader() {\n    this.runtime.selectedColumns = [];\n    if (this.runtime.headers) {\n      const headers = this.runtime.headers;\n      for (let i = 0; i < headers.length; i++) {\n        if (this.params.ignoreColumns) {\n          if (this.params.ignoreColumns.test(headers[i])) {\n            if (this.params.includeColumns && this.params.includeColumns.test(headers[i])) {\n              this.runtime.selectedColumns.push(i);\n            } else {\n              continue;\n            }\n          } else {\n            this.runtime.selectedColumns.push(i);\n          }\n        } else if (this.params.includeColumns) {\n          if (this.params.includeColumns.test(headers[i])) {\n            this.runtime.selectedColumns.push(i);\n          }\n        } else {\n          this.runtime.selectedColumns.push(i);\n        }\n        // if (this.params.includeColumns && this.params.includeColumns.test(headers[i])){\n        //   this.runtime.selectedColumns.push(i);\n        // }else{\n        //   if (this.params.ignoreColumns && this.params.ignoreColumns.test(headers[i])){\n        //     continue;\n        //   }else{\n        //     if (this.params.ignoreColumns && !this.params.includeColumns){\n        //       this.runtime.selectedColumns.push(i);\n        //     }\n\n        //   }\n        // }\n      }\n      this.runtime.headers = filterArray(this.runtime.headers, this.runtime.selectedColumns);\n    }\n\n  }\n  private processCSVBody(lines: string[]): ProcessLineResult[] {\n    if (this.params.output === \"line\") {\n      return lines;\n    } else {\n      const result = this.rowSplit.parseMultiLines(lines);\n      this.prependLeftBuf(bufFromString(result.partial));\n      if (this.params.output === \"csv\") {\n        return result.rowsCells;\n      } else {\n        return lineToJson(result.rowsCells, this.converter);\n      }\n    }\n\n    // var jsonArr = linesToJson(lines.lines, params, this.recordNum);\n    // this.processResult(jsonArr);\n    // this.lastIndex += jsonArr.length;\n    // this.recordNum += jsonArr.length;\n  }\n\n  private prependLeftBuf(buf: Buffer) {\n    if (buf) {\n      if (this.runtime.csvLineBuffer) {\n        this.runtime.csvLineBuffer = Buffer.concat([buf, this.runtime.csvLineBuffer]);\n      } else {\n        this.runtime.csvLineBuffer = buf;\n      }\n    }\n\n  }\n  private runPreLineHook(lines: string[]): P<string[]> {\n    return new P((resolve, reject) => {\n      processLineHook(lines, this.runtime, 0, (err) => {\n        if (err) {\n          reject(err);\n        } else {\n          resolve(lines);\n        }\n      })\n    });\n  }\n}\n\nfunction processLineHook(lines: string[], runtime: ParseRuntime, offset: number,\n  cb: (err?) => void\n) {\n  if (offset >= lines.length) {\n    cb();\n  } else {\n    if (runtime.preFileLineHook) {\n      const line = lines[offset];\n      const res = runtime.preFileLineHook(line, runtime.parsedLineNumber + offset);\n      offset++;\n      if (res && (res as PromiseLike<string>).then) {\n        (res as PromiseLike<string>).then((value) => {\n          lines[offset - 1] = value;\n          processLineHook(lines, runtime, offset, cb);\n        });\n      } else {\n        lines[offset - 1] = res as string;\n        while (offset < lines.length) {\n          lines[offset] = runtime.preFileLineHook(lines[offset], runtime.parsedLineNumber + offset) as string;\n          offset++;\n        }\n        cb();\n      }\n    } else {\n      cb();\n    }\n  }\n}"]}

.ts-node/46be5da21...cb6f79647e7f5e59dce04654581288e7e3e7.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var Processor = /** @class */ (function () {
-    function Processor(converter) {
-        this.converter = converter;
-        this.params = converter.parseParam;
-        this.runtime = converter.parseRuntime;
-    }
-    return Processor;
-}());
-exports.Processor = Processor;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9Qcm9jZXNzb3IudHMiLCJzb3VyY2VzIjpbIi9Vc2Vycy9reGlhbmcvd29yay9wcm9qZWN0cy9jc3YyanNvbi9zcmMvUHJvY2Vzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBTUE7SUFHRSxtQkFBc0IsU0FBb0I7UUFBcEIsY0FBUyxHQUFULFNBQVMsQ0FBVztRQUN4QyxJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxVQUFVLENBQUM7UUFDbkMsSUFBSSxDQUFDLE9BQU8sR0FBRyxTQUFTLENBQUMsWUFBWSxDQUFDO0lBQ3hDLENBQUM7SUFJSCxnQkFBQztBQUFELENBQUMsQUFWRCxJQVVDO0FBVnFCLDhCQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udmVydGVyIH0gZnJvbSBcIi4vQ29udmVydGVyXCI7XG5pbXBvcnQgUCBmcm9tIFwiYmx1ZWJpcmRcIjtcbmltcG9ydCB7IEpTT05SZXN1bHQgfSBmcm9tIFwiLi9saW5lVG9Kc29uXCI7XG5pbXBvcnQgeyBDU1ZQYXJzZVBhcmFtIH0gZnJvbSBcIi4vUGFyYW1ldGVyc1wiO1xuaW1wb3J0IHsgUGFyc2VSdW50aW1lIH0gZnJvbSBcIi4vUGFyc2VSdW50aW1lXCI7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBQcm9jZXNzb3Ige1xuICBwcm90ZWN0ZWQgcGFyYW1zOiBDU1ZQYXJzZVBhcmFtO1xuICBwcm90ZWN0ZWQgcnVudGltZTogUGFyc2VSdW50aW1lO1xuICBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgY29udmVydGVyOiBDb252ZXJ0ZXIpIHtcbiAgICB0aGlzLnBhcmFtcyA9IGNvbnZlcnRlci5wYXJzZVBhcmFtO1xuICAgIHRoaXMucnVudGltZSA9IGNvbnZlcnRlci5wYXJzZVJ1bnRpbWU7XG4gIH1cbiAgYWJzdHJhY3QgcHJvY2VzcyhjaHVuazogQnVmZmVyLGZpbmFsQ2h1bms/OmJvb2xlYW4pOiBQPFByb2Nlc3NMaW5lUmVzdWx0W10+XG4gIGFic3RyYWN0IGRlc3Ryb3koKTpQPHZvaWQ+O1xuICBhYnN0cmFjdCBmbHVzaCgpOiBQPFByb2Nlc3NMaW5lUmVzdWx0W10+O1xufVxuZXhwb3J0IHR5cGUgUHJvY2Vzc0xpbmVSZXN1bHQgPSBzdHJpbmcgfCBzdHJpbmdbXSB8IEpTT05SZXN1bHQ7XG4iXX0=

.ts-node/46be5da21...b34a0413289c51d292e3fc966b03f2cac468.js

-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var stream_1 = require("stream");
-var Parameters_1 = require("./Parameters");
-var ParseRuntime_1 = require("./ParseRuntime");
-var bluebird_1 = __importDefault(require("bluebird"));
-// import { ProcessorFork } from "./ProcessFork";
-var ProcessorLocal_1 = require("./ProcessorLocal");
-var Result_1 = require("./Result");
-var Converter = /** @class */ (function (_super) {
-    __extends(Converter, _super);
-    function Converter(param, options) {
-        if (options === void 0) { options = {}; }
-        var _this = _super.call(this, options) || this;
-        _this.options = options;
-        _this.params = Parameters_1.mergeParams(param);
-        _this.runtime = ParseRuntime_1.initParseRuntime(_this);
-        _this.result = new Result_1.Result(_this);
-        // if (this.params.fork) {
-        //   this.processor = new ProcessorFork(this);
-        // } else {
-        _this.processor = new ProcessorLocal_1.ProcessorLocal(_this);
-        // }
-        _this.once("error", function (err) {
-            // console.log("BBB");
-            setTimeout(function () {
-                _this.result.processError(err);
-                _this.emit("done", err);
-            }, 0);
-        });
-        _this.once("done", function () {
-            _this.processor.destroy();
-        });
-        return _this;
-    }
-    Converter.prototype.preRawData = function (onRawData) {
-        this.runtime.preRawDataHook = onRawData;
-        return this;
-    };
-    Converter.prototype.preFileLine = function (onFileLine) {
-        this.runtime.preFileLineHook = onFileLine;
-        return this;
-    };
-    Converter.prototype.subscribe = function (onNext, onError, onCompleted) {
-        this.parseRuntime.subscribe = {
-            onNext: onNext,
-            onError: onError,
-            onCompleted: onCompleted
-        };
-        return this;
-    };
-    Converter.prototype.fromFile = function (filePath, options) {
-        var _this = this;
-        var fs = require("fs");
-        // var rs = null;
-        // this.wrapCallback(cb, function () {
-        //   if (rs && rs.destroy) {
-        //     rs.destroy();
-        //   }
-        // });
-        fs.exists(filePath, function (exist) {
-            if (exist) {
-                var rs = fs.createReadStream(filePath, options);
-                rs.pipe(_this);
-            }
-            else {
-                _this.emit('error', new Error("File does not exist. Check to make sure the file path to your csv is correct."));
-            }
-        });
-        return this;
-    };
-    Converter.prototype.fromStream = function (readStream) {
-        readStream.pipe(this);
-        return this;
-    };
-    Converter.prototype.fromString = function (csvString) {
-        var csv = csvString.toString();
-        var read = new stream_1.Readable();
-        var idx = 0;
-        read._read = function (size) {
-            if (idx >= csvString.length) {
-                this.push(null);
-            }
-            else {
-                var str = csvString.substr(idx, size);
-                this.push(str);
-                idx += size;
-            }
-        };
-        return this.fromStream(read);
-    };
-    Converter.prototype.then = function (onfulfilled, onrejected) {
-        var _this = this;
-        return new bluebird_1.default(function (resolve, reject) {
-            _this.parseRuntime.then = {
-                onfulfilled: function (value) {
-                    if (onfulfilled) {
-                        resolve(onfulfilled(value));
-                    }
-                    else {
-                        resolve(value);
-                    }
-                },
-                onrejected: function (err) {
-                    if (onrejected) {
-                        resolve(onrejected(err));
-                    }
-                    else {
-                        reject(err);
-                    }
-                }
-            };
-        });
-    };
-    Object.defineProperty(Converter.prototype, "parseParam", {
-        get: function () {
-            return this.params;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Converter.prototype, "parseRuntime", {
-        get: function () {
-            return this.runtime;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Converter.prototype._transform = function (chunk, encoding, cb) {
-        var _this = this;
-        this.processor.process(chunk)
-            .then(function (result) {
-            // console.log(result);
-            if (result.length > 0) {
-                _this.runtime.started = true;
-                return _this.result.processResult(result);
-            }
-        })
-            .then(function () {
-            _this.emit("drained");
-            cb();
-        }, function (error) {
-            _this.runtime.hasError = true;
-            _this.runtime.error = error;
-            _this.emit("error", error);
-            cb();
-        });
-    };
-    Converter.prototype._flush = function (cb) {
-        var _this = this;
-        this.processor.flush()
-            .then(function (data) {
-            if (data.length > 0) {
-                return _this.result.processResult(data);
-            }
-        })
-            .then(function () {
-            _this.processEnd(cb);
-        }, function (err) {
-            _this.emit("error", err);
-            cb();
-        });
-    };
-    Converter.prototype.processEnd = function (cb) {
-        this.result.endProcess();
-        this.emit("done");
-        cb();
-    };
-    Object.defineProperty(Converter.prototype, "parsedLineNumber", {
-        get: function () {
-            return this.runtime.parsedLineNumber;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return Converter;
-}(stream_1.Transform));
-exports.Converter = Converter;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/Converter.ts","sources":["/Users/kxiang/work/projects/csv2json/src/Converter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transform, TransformOptions, Readable } from \"stream\";\nimport { CSVParseParam, mergeParams } from \"./Parameters\";\nimport { ParseRuntime, initParseRuntime } from \"./ParseRuntime\";\nimport P from \"bluebird\";\nimport { stringToLines } from \"./fileline\";\nimport { map } from \"lodash/map\";\nimport { RowSplit, RowSplitResult } from \"./rowSplit\";\nimport getEol from \"./getEol\";\nimport lineToJson, { JSONResult } from \"./lineToJson\";\nimport { Processor, ProcessLineResult } from \"./Processor\";\n// import { ProcessorFork } from \"./ProcessFork\";\nimport { ProcessorLocal } from \"./ProcessorLocal\";\nimport { Result } from \"./Result\";\nimport CSVError from \"./CSVError\";\nimport { bufFromString } from \"./util\";\n\n\n\nexport class Converter extends Transform implements PromiseLike<Array<any>> {\n  preRawData(onRawData: PreRawDataCallback): Converter {\n    this.runtime.preRawDataHook = onRawData;\n    return this;\n  }\n  preFileLine(onFileLine: PreFileLineCallback): Converter {\n    this.runtime.preFileLineHook = onFileLine;\n    return this;\n  }\n  subscribe(\n    onNext?: (data: any, lineNumber: number) => void | PromiseLike<void>,\n    onError?: (err: CSVError) => void,\n    onCompleted?: () => void): Converter {\n    this.parseRuntime.subscribe = {\n      onNext,\n      onError,\n      onCompleted\n    }\n    return this;\n  }\n  fromFile(filePath: string, options?: string | CreateReadStreamOption | undefined): Converter {\n    const fs = require(\"fs\");\n    // var rs = null;\n    // this.wrapCallback(cb, function () {\n    //   if (rs && rs.destroy) {\n    //     rs.destroy();\n    //   }\n    // });\n    fs.exists(filePath, (exist) => {\n      if (exist) {\n        const rs = fs.createReadStream(filePath, options);\n        rs.pipe(this);\n      } else {\n        this.emit('error', new Error(\"File does not exist. Check to make sure the file path to your csv is correct.\"));\n      }\n    });\n    return this;\n  }\n  fromStream(readStream: Readable): Converter {\n    readStream.pipe(this);\n    return this;\n  }\n  fromString(csvString: string): Converter {\n    const csv = csvString.toString();\n    const read = new Readable();\n    let idx = 0;\n    read._read = function (size) {\n      if (idx >= csvString.length) {\n        this.push(null);\n      } else {\n        const str = csvString.substr(idx, size);\n        this.push(str);\n        idx += size;\n      }\n    }\n    return this.fromStream(read);\n  }\n  then<TResult1 = any[], TResult2 = never>(onfulfilled?: (value: any[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2> {\n    return new P((resolve, reject) => {\n      this.parseRuntime.then = {\n        onfulfilled: (value: any[]) => {\n          if (onfulfilled) {\n            resolve(onfulfilled(value));\n          } else {\n            resolve(value as any);\n          }\n        },\n        onrejected: (err: Error) => {\n          if (onrejected) {\n            resolve(onrejected(err));\n          } else {\n            reject(err);\n          }\n        }\n      }\n    });\n  }\n  public get parseParam(): CSVParseParam {\n    return this.params;\n  }\n  public get parseRuntime(): ParseRuntime {\n    return this.runtime;\n  }\n  private params: CSVParseParam;\n  private runtime: ParseRuntime;\n  private processor: Processor;\n  private result: Result;\n  constructor(param?: Partial<CSVParseParam>, public options: TransformOptions = {}) {\n    super(options);\n    this.params = mergeParams(param);\n    this.runtime = initParseRuntime(this);\n    this.result = new Result(this);\n    // if (this.params.fork) {\n    //   this.processor = new ProcessorFork(this);\n    // } else {\n    this.processor = new ProcessorLocal(this);\n    // }\n    this.once(\"error\", (err: any) => {\n      // console.log(\"BBB\");\n\n      setTimeout(() => {\n        this.result.processError(err);\n        this.emit(\"done\", err);\n      }, 0);\n\n    });\n    this.once(\"done\", () => {\n      this.processor.destroy();\n    })\n\n    return this;\n  }\n  _transform(chunk: any, encoding: string, cb: Function) {\n    this.processor.process(chunk)\n      .then((result) => {\n        // console.log(result);\n        if (result.length > 0) {\n          this.runtime.started = true;\n\n          return this.result.processResult(result);\n        }\n      })\n      .then(() => {\n        this.emit(\"drained\");\n        cb();\n      }, (error) => {\n        this.runtime.hasError = true;\n        this.runtime.error = error;\n        this.emit(\"error\", error);\n        cb();\n      });\n  }\n  _flush(cb: Function) {\n    this.processor.flush()\n      .then((data) => {\n        if (data.length > 0) {\n\n          return this.result.processResult(data);\n        }\n      })\n      .then(() => {\n        this.processEnd(cb);\n      }, (err) => {\n        this.emit(\"error\", err);\n        cb();\n      })\n  }\n  private processEnd(cb) {\n    this.result.endProcess();\n    this.emit(\"done\");\n    cb();\n  }\n  get parsedLineNumber(): number {\n    return this.runtime.parsedLineNumber;\n  }\n}\nexport interface CreateReadStreamOption {\n  flags?: string;\n  encoding?: string;\n  fd?: number;\n  mode?: number;\n  autoClose?: boolean;\n  start?: number;\n  end?: number;\n  highWaterMark?: number;\n}\nexport type CallBack = (err: Error, data: Array<any>) => void;\n\n\nexport type PreFileLineCallback = (line: string, lineNumber: number) => string | PromiseLike<string>;\nexport type PreRawDataCallback = (csvString: string) => string | PromiseLike<string>;\n"]}

.ts-node/46be5da21...3baabb47d90efcb26810c79a570fed5ad880.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//return first eol found from a data chunk.
-function default_1(data, param) {
-    if (!param.eol && data) {
-        for (var i = 0, len = data.length; i < len; i++) {
-            if (data[i] === "\r") {
-                if (data[i + 1] === "\n") {
-                    param.eol = "\r\n";
-                    break;
-                }
-                else if (data[i + 1]) {
-                    param.eol = "\r";
-                    break;
-                }
-            }
-            else if (data[i] === "\n") {
-                param.eol = "\n";
-                break;
-            }
-        }
-    }
-    return param.eol || "\n";
-}
-exports.default = default_1;
-;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9nZXRFb2wudHMiLCJzb3VyY2VzIjpbIi9Vc2Vycy9reGlhbmcvd29yay9wcm9qZWN0cy9jc3YyanNvbi9zcmMvZ2V0RW9sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQ0EsMkNBQTJDO0FBQzNDLG1CQUF5QixJQUFZLEVBQUUsS0FBbUI7SUFDeEQsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLElBQUksSUFBSSxFQUFFO1FBQ3RCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEdBQUcsR0FBRyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsR0FBRyxHQUFHLEVBQUUsQ0FBQyxFQUFFLEVBQUU7WUFDL0MsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssSUFBSSxFQUFFO2dCQUNwQixJQUFJLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssSUFBSSxFQUFFO29CQUN4QixLQUFLLENBQUMsR0FBRyxHQUFHLE1BQU0sQ0FBQztvQkFDbkIsTUFBTTtpQkFDUDtxQkFBTSxJQUFJLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUU7b0JBQ3RCLEtBQUssQ0FBQyxHQUFHLEdBQUcsSUFBSSxDQUFDO29CQUNqQixNQUFNO2lCQUNQO2FBQ0Y7aUJBQU0sSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssSUFBSSxFQUFFO2dCQUMzQixLQUFLLENBQUMsR0FBRyxHQUFHLElBQUksQ0FBQztnQkFDakIsTUFBTTthQUNQO1NBQ0Y7S0FDRjtJQUNELE9BQU8sS0FBSyxDQUFDLEdBQUcsSUFBSSxJQUFJLENBQUM7QUFDM0IsQ0FBQztBQWxCRCw0QkFrQkM7QUFBQSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGFyc2VSdW50aW1lIH0gZnJvbSBcIi4vUGFyc2VSdW50aW1lXCI7XG4vL3JldHVybiBmaXJzdCBlb2wgZm91bmQgZnJvbSBhIGRhdGEgY2h1bmsuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiAoZGF0YTogc3RyaW5nLCBwYXJhbTogUGFyc2VSdW50aW1lKTogc3RyaW5nIHtcbiAgaWYgKCFwYXJhbS5lb2wgJiYgZGF0YSkge1xuICAgIGZvciAodmFyIGkgPSAwLCBsZW4gPSBkYXRhLmxlbmd0aDsgaSA8IGxlbjsgaSsrKSB7XG4gICAgICBpZiAoZGF0YVtpXSA9PT0gXCJcXHJcIikge1xuICAgICAgICBpZiAoZGF0YVtpICsgMV0gPT09IFwiXFxuXCIpIHtcbiAgICAgICAgICBwYXJhbS5lb2wgPSBcIlxcclxcblwiO1xuICAgICAgICAgIGJyZWFrO1xuICAgICAgICB9IGVsc2UgaWYgKGRhdGFbaSArIDFdKSB7XG4gICAgICAgICAgcGFyYW0uZW9sID0gXCJcXHJcIjtcbiAgICAgICAgICBicmVhaztcbiAgICAgICAgfSBcbiAgICAgIH0gZWxzZSBpZiAoZGF0YVtpXSA9PT0gXCJcXG5cIikge1xuICAgICAgICBwYXJhbS5lb2wgPSBcIlxcblwiO1xuICAgICAgICBicmVhaztcbiAgICAgIH1cbiAgICB9XG4gIH1cbiAgcmV0dXJuIHBhcmFtLmVvbCB8fCBcIlxcblwiO1xufTtcbiJdfQ==

.ts-node/46be5da21...531410ecb53ccdbe486e410336329db2fdb4.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var rowSplit_1 = require("./rowSplit");
-var Converter_1 = require("./Converter");
-var assert = require("assert");
-describe("Test delimiters", function () {
-    var getDelimiter = function (str, opt) {
-        return rowSplit_1.RowSplit.prototype["getDelimiter"].call({
-            conv: {
-                parseParam: {
-                    delimiter: opt.delimiter
-                }
-            }
-        }, str);
-    };
-    it("should return the explicitly specified delimiter", function () {
-        var delimiter = ";";
-        var rowStr = "a;b;c";
-        var returnedDelimiter = getDelimiter(rowStr, { delimiter: ";" });
-        assert.equal(returnedDelimiter, delimiter);
-    });
-    it("should return the autodetected delimiter if 'auto' specified", function () {
-        var rowStr = "a;b;c";
-        var returnedDelimiter = getDelimiter(rowStr, { delimiter: "auto" });
-        assert(returnedDelimiter === ";");
-    });
-    it("should return the ',' delimiter if delimiter cannot be specified, in case of 'auto'", function () {
-        var rowStr = "abc";
-        var returnedDelimiter = getDelimiter(rowStr, { delimiter: "auto" });
-        assert(returnedDelimiter === ",");
-    });
-    it("should accetp an array with potential delimiters", function () {
-        var rowStr = "a$b$c";
-        var returnedDelimiter = getDelimiter(rowStr, { delimiter: [",", ";", "$"] });
-        assert(returnedDelimiter === '$');
-    });
-});
-describe("ParseMultiLine function", function () {
-    var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter());
-    var func = function (lines) {
-        return rowSplit.parseMultiLines(lines);
-    };
-    it("should convert lines to csv lines", function () {
-        var lines = [
-            "a,b,c,d",
-            "hello,world,csvtojson,abc",
-            "1,2,3,4"
-        ];
-        var res = func(lines);
-        assert.equal(res.rowsCells.length, 3);
-        assert.equal(res.partial, "");
-    });
-    it("should process line breaks", function () {
-        var lines = [
-            "a,b,c",
-            '15",hello,"ab',
-            "cde\"",
-            "\"b\"\"b\",cc,dd"
-        ];
-        var res = func(lines);
-        assert.equal(res.rowsCells.length, 3);
-        assert.equal(res.rowsCells[1][0], "15\"");
-        assert.equal(res.rowsCells[1][2], "ab\ncde");
-        assert.equal(res.rowsCells[2][0], "b\"b");
-        assert.equal(res.partial, "");
-    });
-    it("should return partial if line not closed", function () {
-        var lines = [
-            "a,b,c",
-            '15",hello,"ab',
-            "d,e,f"
-        ];
-        var res = func(lines);
-        assert.equal(res.rowsCells.length, 1);
-        assert.equal(res.partial, "15\",hello,\"ab\nd,e,f\n");
-    });
-});
-describe("RowSplit.parse function", function () {
-    var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter());
-    var func = function (str) {
-        return rowSplit.parse(str);
-    };
-    it("should split complete csv line", function () {
-        var str = "hello,world,csvtojson,awesome";
-        var res = func(str);
-        assert.equal(res.cells.length, 4);
-        assert.equal(res.closed, true);
-    });
-    it("should split incomplete csv line", function () {
-        var str = "hello,world,\"csvtojson,awesome";
-        var res = func(str);
-        assert.equal(res.closed, false);
-    });
-    it("should allow multiple line", function () {
-        var str = "\"he\"llo\",world,\"csvtojson,a\"\nwesome\"";
-        var res = func(str);
-        assert.equal(res.closed, true);
-        assert.equal(res.cells[2], 'csvtojson,a"\nwesome');
-    });
-    it("should allow blank quotes", function () {
-        var data = "a|^^|^b^";
-        var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter({
-            delimiter: '|',
-            quote: '^',
-            noheader: true
-        }));
-        var res = rowSplit.parse(data);
-        assert.equal(res.cells[1], "");
-    });
-    it("should allow blank quotes in quotes", function () {
-        var data = 'a,"hello,this,"", test"';
-        var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter({
-            noheader: true
-        }));
-        var res = rowSplit.parse(data);
-        assert.equal(res.cells[1], 'hello,this,", test');
-    });
-    it("should smart detect if an initial quote is only part of value ", function () {
-        var data = '"Weight" (kg),Error code,"Height" (m)';
-        var rowSplit = new rowSplit_1.RowSplit(new Converter_1.Converter({
-            noheader: true
-        }));
-        var res = rowSplit.parse(data);
-        assert.equal(res.cells.length, 3);
-        assert(res.closed);
-        assert.equal(res.cells[0], '"Weight" (kg)');
-        assert.equal(res.cells[1], 'Error code');
-        assert.equal(res.cells[2], '"Height" (m)');
-    });
-});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/rowSplit.test.ts","sources":["/Users/kxiang/work/projects/csv2json/src/rowSplit.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { RowSplit, MultipleRowResult, RowSplitResult } from \"./rowSplit\";\nimport { Converter } from \"./Converter\";\nconst assert = require(\"assert\");\n\ndescribe(\"Test delimiters\", function () {\n  const getDelimiter = (str, opt: { delimiter: string | string[] }): string => {\n    return RowSplit.prototype[\"getDelimiter\"].call({\n      conv: {\n        parseParam: {\n          delimiter: opt.delimiter\n        }\n      }\n    }, str);\n  }\n\n  it(\"should return the explicitly specified delimiter\", function () {\n    var delimiter = \";\";\n    var rowStr = \"a;b;c\";\n    var returnedDelimiter = getDelimiter(rowStr, { delimiter: \";\" });\n    assert.equal(returnedDelimiter, delimiter);\n  });\n\n  it(\"should return the autodetected delimiter if 'auto' specified\", function () {\n    var rowStr = \"a;b;c\";\n    var returnedDelimiter = getDelimiter(rowStr, { delimiter: \"auto\" });\n    assert(returnedDelimiter === \";\");\n  });\n\n  it(\"should return the ',' delimiter if delimiter cannot be specified, in case of 'auto'\", function () {\n    var rowStr = \"abc\";\n    var returnedDelimiter = getDelimiter(rowStr, { delimiter: \"auto\" });\n    assert(returnedDelimiter === \",\");\n  });\n\n  it(\"should accetp an array with potential delimiters\", function () {\n    var rowStr = \"a$b$c\";\n    var returnedDelimiter = getDelimiter(rowStr, { delimiter: [\",\", \";\", \"$\"] });\n    assert(returnedDelimiter === '$');\n  });\n});\n\ndescribe(\"ParseMultiLine function\", function () {\n  const rowSplit = new RowSplit(new Converter());\n  const func = (lines: string[]): MultipleRowResult => {\n    return rowSplit.parseMultiLines(lines);\n  }\n  it(\"should convert lines to csv lines\", function () {\n    var lines = [\n      \"a,b,c,d\",\n      \"hello,world,csvtojson,abc\",\n      \"1,2,3,4\"\n    ];\n    var res = func(lines);\n    assert.equal(res.rowsCells.length, 3);\n    assert.equal(res.partial, \"\");\n  });\n\n  it(\"should process line breaks\", function () {\n    var lines = [\n      \"a,b,c\",\n      '15\",hello,\"ab',\n      \"cde\\\"\",\n      \"\\\"b\\\"\\\"b\\\",cc,dd\"\n    ];\n    var res = func(lines);\n    assert.equal(res.rowsCells.length, 3);\n    assert.equal(res.rowsCells[1][0], \"15\\\"\");\n    assert.equal(res.rowsCells[1][2], \"ab\\ncde\");\n    assert.equal(res.rowsCells[2][0], \"b\\\"b\");\n    assert.equal(res.partial, \"\");\n  });\n\n  it(\"should return partial if line not closed\", function () {\n    var lines = [\n      \"a,b,c\",\n      '15\",hello,\"ab',\n      \"d,e,f\"\n    ];\n    var res = func(lines);\n    assert.equal(res.rowsCells.length, 1);\n    assert.equal(res.partial, \"15\\\",hello,\\\"ab\\nd,e,f\\n\");\n  });\n});\n\ndescribe(\"RowSplit.parse function\", function () {\n  const rowSplit = new RowSplit(new Converter());\n  const func = (str): RowSplitResult => {\n    return rowSplit.parse(str);\n  }\n  it(\"should split complete csv line\", function () {\n    var str = \"hello,world,csvtojson,awesome\";\n    var res = func(str);\n    assert.equal(res.cells.length, 4);\n    assert.equal(res.closed, true);\n  });\n\n  it(\"should split incomplete csv line\", function () {\n    var str = \"hello,world,\\\"csvtojson,awesome\";\n    var res = func(str);\n    assert.equal(res.closed, false);\n  });\n\n  it(\"should allow multiple line\", function () {\n    var str = \"\\\"he\\\"llo\\\",world,\\\"csvtojson,a\\\"\\nwesome\\\"\";\n    var res = func(str);\n    assert.equal(res.closed, true);\n    assert.equal(res.cells[2], 'csvtojson,a\"\\nwesome');\n  });\n  it(\"should allow blank quotes\", () => {\n    const data = \"a|^^|^b^\";\n\n    const rowSplit = new RowSplit(new Converter({\n      delimiter: '|',\n      quote: '^',\n      noheader: true\n    }));\n    const res = rowSplit.parse(data);\n    assert.equal(res.cells[1], \"\");\n  })\n  it(\"should allow blank quotes in quotes\", () => {\n    const data = 'a,\"hello,this,\"\", test\"';\n\n    const rowSplit = new RowSplit(new Converter({\n      noheader: true\n    }));\n    const res = rowSplit.parse(data);\n    assert.equal(res.cells[1], 'hello,this,\", test');\n  })\n  it(\"should smart detect if an initial quote is only part of value \", () => {\n    const data = '\"Weight\" (kg),Error code,\"Height\" (m)';\n    const rowSplit = new RowSplit(new Converter({\n      noheader: true\n    }));\n    const res = rowSplit.parse(data);\n    assert.equal(res.cells.length, 3);\n    assert(res.closed);\n    assert.equal(res.cells[0],'\"Weight\" (kg)');\n    assert.equal(res.cells[1],'Error code');\n    assert.equal(res.cells[2],'\"Height\" (m)');\n    \n  })\n});\n"]}

.ts-node/46be5da21...1a1baa361e29c2df52092099a5376d037cb9.js

-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var getEol_1 = __importDefault(require("./getEol"));
-// const getEol = require("./getEol");
-/**
- * convert data chunk to file lines array
- * @param  {string} data  data chunk as utf8 string
- * @param  {object} param Converter param object
- * @return {Object}   {lines:[line1,line2...],partial:String}
- */
-function stringToLines(data, param) {
-    var eol = getEol_1.default(data, param);
-    var lines = data.split(eol);
-    var partial = lines.pop() || "";
-    return { lines: lines, partial: partial };
-}
-exports.stringToLines = stringToLines;
-;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9maWxlbGluZS50cyIsInNvdXJjZXMiOlsiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9maWxlbGluZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUNBLG9EQUE4QjtBQUM5QixzQ0FBc0M7QUFDdEM7Ozs7O0dBS0c7QUFDSCx1QkFBOEIsSUFBWSxFQUFFLEtBQW1CO0lBQzdELElBQU0sR0FBRyxHQUFHLGdCQUFNLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ2hDLElBQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDOUIsSUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUNsQyxPQUFPLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFDNUMsQ0FBQztBQUxELHNDQUtDO0FBQUEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBhcnNlUnVudGltZSB9IGZyb20gXCIuL1BhcnNlUnVudGltZVwiO1xuaW1wb3J0IGdldEVvbCBmcm9tIFwiLi9nZXRFb2xcIjtcbi8vIGNvbnN0IGdldEVvbCA9IHJlcXVpcmUoXCIuL2dldEVvbFwiKTtcbi8qKlxuICogY29udmVydCBkYXRhIGNodW5rIHRvIGZpbGUgbGluZXMgYXJyYXlcbiAqIEBwYXJhbSAge3N0cmluZ30gZGF0YSAgZGF0YSBjaHVuayBhcyB1dGY4IHN0cmluZ1xuICogQHBhcmFtICB7b2JqZWN0fSBwYXJhbSBDb252ZXJ0ZXIgcGFyYW0gb2JqZWN0XG4gKiBAcmV0dXJuIHtPYmplY3R9ICAge2xpbmVzOltsaW5lMSxsaW5lMi4uLl0scGFydGlhbDpTdHJpbmd9XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzdHJpbmdUb0xpbmVzKGRhdGE6IHN0cmluZywgcGFyYW06IFBhcnNlUnVudGltZSk6IFN0cmluZ1RvTGluZXNSZXN1bHQge1xuICBjb25zdCBlb2wgPSBnZXRFb2woZGF0YSwgcGFyYW0pO1xuICBjb25zdCBsaW5lcyA9IGRhdGEuc3BsaXQoZW9sKTtcbiAgY29uc3QgcGFydGlhbCA9IGxpbmVzLnBvcCgpIHx8IFwiXCI7XG4gIHJldHVybiB7IGxpbmVzOiBsaW5lcywgcGFydGlhbDogcGFydGlhbCB9O1xufTtcblxuXG5leHBvcnQgaW50ZXJmYWNlIFN0cmluZ1RvTGluZXNSZXN1bHQge1xuICBsaW5lczogRmlsZWxpbmVbXSxcbiAgLyoqXG4gICAqIGxhc3QgbGluZSB3aGljaCBjb3VsZCBiZSBpbmNvbXBsZXRlIGxpbmUuXG4gICAqL1xuICBwYXJ0aWFsOiBzdHJpbmdcbn1cbmV4cG9ydCB0eXBlIEZpbGVsaW5lID0gc3RyaW5nOyJdfQ==

.ts-node/46be5da21...8e80ba4e28d41394c7291bd5dd6d6617e7a8.js

-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var CSVError_1 = __importDefault(require("./CSVError"));
-var set_1 = __importDefault(require("lodash/set"));
-var numReg = /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/;
-function default_1(csvRows, conv) {
-    var res = [];
-    for (var i = 0, len = csvRows.length; i < len; i++) {
-        var r = processRow(csvRows[i], conv, i);
-        if (r) {
-            res.push(r);
-        }
-    }
-    return res;
-}
-exports.default = default_1;
-;
-function processRow(row, conv, index) {
-    if (conv.parseParam.checkColumn && conv.parseRuntime.headers && row.length !== conv.parseRuntime.headers.length) {
-        throw (CSVError_1.default.column_mismatched(conv.parseRuntime.parsedLineNumber + index));
-    }
-    var headRow = conv.parseRuntime.headers || [];
-    var resultRow = convertRowToJson(row, headRow, conv);
-    if (resultRow) {
-        return resultRow;
-    }
-    else {
-        return null;
-    }
-}
-function convertRowToJson(row, headRow, conv) {
-    var hasValue = false;
-    var resultRow = {};
-    for (var i = 0, len = row.length; i < len; i++) {
-        var item = row[i];
-        if (conv.parseParam.ignoreEmpty && item === '') {
-            continue;
-        }
-        hasValue = true;
-        var head = headRow[i];
-        if (!head || head === "") {
-            head = headRow[i] = "field" + (i + 1);
-        }
-        var convFunc = getConvFunc(head, i, conv);
-        if (convFunc) {
-            var convRes = convFunc(item, head, resultRow, row, i);
-            if (convRes !== undefined) {
-                setPath(resultRow, head, convRes, conv, i);
-            }
-        }
-        else {
-            // var flag = getFlag(head, i, param);
-            // if (flag === 'omit') {
-            //   continue;
-            // }
-            if (conv.parseParam.checkType) {
-                var convertFunc = checkType(item, head, i, conv);
-                item = convertFunc(item);
-            }
-            if (item !== undefined) {
-                setPath(resultRow, head, item, conv, i);
-            }
-        }
-    }
-    if (hasValue) {
-        return resultRow;
-    }
-    else {
-        return null;
-    }
-}
-var builtInConv = {
-    "string": stringType,
-    "number": numberType,
-    "omit": function () { }
-};
-function getConvFunc(head, i, conv) {
-    if (conv.parseRuntime.columnConv[i] !== undefined) {
-        return conv.parseRuntime.columnConv[i];
-    }
-    else {
-        var flag = conv.parseParam.colParser[head];
-        if (flag === undefined) {
-            return conv.parseRuntime.columnConv[i] = null;
-        }
-        if (typeof flag === "object") {
-            flag = flag.cellParser || "string";
-        }
-        if (typeof flag === "string") {
-            flag = flag.trim().toLowerCase();
-            var builtInFunc = builtInConv[flag];
-            if (builtInFunc) {
-                return conv.parseRuntime.columnConv[i] = builtInFunc;
-            }
-            else {
-                return conv.parseRuntime.columnConv[i] = null;
-            }
-        }
-        else if (typeof flag === "function") {
-            return conv.parseRuntime.columnConv[i] = flag;
-        }
-        else {
-            return conv.parseRuntime.columnConv[i] = null;
-        }
-    }
-}
-function setPath(resultJson, head, value, conv, headIdx) {
-    if (!conv.parseRuntime.columnValueSetter[headIdx]) {
-        if (conv.parseParam.flatKeys) {
-            conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;
-        }
-        else {
-            if (head.indexOf(".") > -1) {
-                if (conv.parseParam.colParser[head] && conv.parseParam.colParser[head].flat) {
-                    conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;
-                }
-                else {
-                    conv.parseRuntime.columnValueSetter[headIdx] = jsonSetter;
-                }
-            }
-            else {
-                conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;
-            }
-        }
-    }
-    conv.parseRuntime.columnValueSetter[headIdx](resultJson, head, value);
-    // flatSetter(resultJson, head, value);
-}
-function flatSetter(resultJson, head, value) {
-    resultJson[head] = value;
-}
-function jsonSetter(resultJson, head, value) {
-    set_1.default(resultJson, head, value);
-}
-function checkType(item, head, headIdx, conv) {
-    if (conv.parseRuntime.headerType[headIdx]) {
-        return conv.parseRuntime.headerType[headIdx];
-    }
-    else if (head.indexOf('number#!') > -1) {
-        return conv.parseRuntime.headerType[headIdx] = numberType;
-    }
-    else if (head.indexOf('string#!') > -1) {
-        return conv.parseRuntime.headerType[headIdx] = stringType;
-    }
-    else if (conv.parseParam.checkType) {
-        return conv.parseRuntime.headerType[headIdx] = dynamicType;
-    }
-    else {
-        return conv.parseRuntime.headerType[headIdx] = stringType;
-    }
-}
-function numberType(item) {
-    var rtn = parseFloat(item);
-    if (isNaN(rtn)) {
-        return item;
-    }
-    return rtn;
-}
-function stringType(item) {
-    return item.toString();
-}
-function dynamicType(item) {
-    var trimed = item.trim();
-    if (trimed === "") {
-        return stringType(item);
-    }
-    if (numReg.test(trimed)) {
-        return numberType(item);
-    }
-    else if (trimed.length === 5 && trimed.toLowerCase() === "false" || trimed.length === 4 && trimed.toLowerCase() === "true") {
-        return booleanType(item);
-    }
-    else if (trimed[0] === "{" && trimed[trimed.length - 1] === "}" || trimed[0] === "[" && trimed[trimed.length - 1] === "]") {
-        return jsonType(item);
-    }
-    else {
-        return stringType(item);
-    }
-}
-function booleanType(item) {
-    var trimed = item.trim();
-    if (trimed.length === 5 && trimed.toLowerCase() === "false") {
-        return false;
-    }
-    else {
-        return true;
-    }
-}
-function jsonType(item) {
-    try {
-        return JSON.parse(item);
-    }
-    catch (e) {
-        return item;
-    }
-}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/lineToJson.ts","sources":["/Users/kxiang/work/projects/csv2json/src/lineToJson.ts"],"names":[],"mappings":"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","sourcesContent":["import { Converter } from \"./Converter\";\nimport CSVError from \"./CSVError\";\nimport { CellParser, ColumnParam } from \"./Parameters\";\nimport set from \"lodash/set\";\nimport { ParseRuntime } from \"./ParseRuntime\";\n\nvar numReg = /^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$/;\n\nexport default function (csvRows: string[][], conv: Converter): JSONResult[] {\n  const res: JSONResult[] = [];\n  for (let i = 0, len = csvRows.length; i < len; i++) {\n    const r = processRow(csvRows[i], conv, i);\n    if (r) {\n      res.push(r);\n    }\n  }\n  return res;\n};\nexport type JSONResult = {\n  [key: string]: any\n}\n\nfunction processRow(row: string[], conv: Converter, index): JSONResult | null {\n\n  if (conv.parseParam.checkColumn && conv.parseRuntime.headers && row.length !== conv.parseRuntime.headers.length) {\n    throw (CSVError.column_mismatched(conv.parseRuntime.parsedLineNumber + index))\n  }\n\n  const headRow = conv.parseRuntime.headers || [];\n  const resultRow = convertRowToJson(row, headRow, conv);\n  if (resultRow) {\n    return resultRow;\n  } else {\n    return null;\n  }\n}\n\nfunction convertRowToJson(row: string[], headRow: string[], conv: Converter): { [key: string]: any } | null {\n  let hasValue = false;\n  const resultRow = {};\n  \n  for (let i = 0, len = row.length; i < len; i++) {\n    let item = row[i];\n\n    if (conv.parseParam.ignoreEmpty && item === '') {\n      continue;\n    }\n    hasValue = true;\n\n    let head = headRow[i];\n    if (!head || head === \"\") {\n      head = headRow[i] = \"field\" + (i + 1);\n    }\n    const convFunc = getConvFunc(head, i, conv);\n    if (convFunc) {\n      const convRes = convFunc(item, head, resultRow, row, i);\n      if (convRes !== undefined) {\n        setPath(resultRow, head, convRes, conv,i);\n      }\n    } else {\n      // var flag = getFlag(head, i, param);\n      // if (flag === 'omit') {\n      //   continue;\n      // }\n      if (conv.parseParam.checkType) {\n        const convertFunc = checkType(item, head, i, conv);\n        item = convertFunc(item);\n      }\n      if (item !== undefined) {\n        setPath(resultRow, head, item, conv,i);\n      }\n    }\n  }\n  if (hasValue) {\n    return resultRow;\n  } else {\n    return null;\n  }\n}\n\nconst builtInConv: { [key: string]: CellParser } = {\n  \"string\": stringType,\n  \"number\": numberType,\n  \"omit\": function () { }\n}\nfunction getConvFunc(head: string, i: number, conv: Converter): CellParser | null {\n  if (conv.parseRuntime.columnConv[i] !== undefined) {\n    return conv.parseRuntime.columnConv[i];\n  } else {\n    let flag = conv.parseParam.colParser[head];\n    if (flag === undefined) {\n      return conv.parseRuntime.columnConv[i] = null;\n    }\n    if (typeof flag === \"object\") {\n      flag = (flag as ColumnParam).cellParser || \"string\";\n    }\n    if (typeof flag === \"string\") {\n      flag = flag.trim().toLowerCase();\n      const builtInFunc = builtInConv[flag];\n      if (builtInFunc) {\n        return conv.parseRuntime.columnConv[i] = builtInFunc;\n      } else {\n        return conv.parseRuntime.columnConv[i] = null;\n      }\n    } else if (typeof flag === \"function\") {\n      return conv.parseRuntime.columnConv[i] = flag;\n    } else {\n      return conv.parseRuntime.columnConv[i] = null;\n    }\n  }\n}\nfunction setPath(resultJson: any, head: string, value: any, conv: Converter,headIdx:number) {\n  if (!conv.parseRuntime.columnValueSetter[headIdx]) {\n    if (conv.parseParam.flatKeys) {\n      conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;\n    } else {\n      if (head.indexOf(\".\") > -1) {\n        if (conv.parseParam.colParser[head] && (conv.parseParam.colParser[head] as ColumnParam).flat) {\n          conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;\n        } else {\n          conv.parseRuntime.columnValueSetter[headIdx] = jsonSetter;\n        }\n      } else {\n        conv.parseRuntime.columnValueSetter[headIdx] = flatSetter;\n      }\n    }\n  }\n  conv.parseRuntime.columnValueSetter[headIdx](resultJson, head, value);\n  // flatSetter(resultJson, head, value);\n\n}\nfunction flatSetter(resultJson: any, head: string, value: any) {\n  resultJson[head] = value;\n}\nfunction jsonSetter(resultJson: any, head: string, value: any) {\n  set(resultJson, head, value);\n}\n\n\nfunction checkType(item: string, head: string, headIdx: number, conv: Converter): Function {\n  if (conv.parseRuntime.headerType[headIdx]) {\n    return conv.parseRuntime.headerType[headIdx];\n  } else if (head.indexOf('number#!') > -1) {\n    return conv.parseRuntime.headerType[headIdx] = numberType;\n  } else if (head.indexOf('string#!') > -1) {\n    return conv.parseRuntime.headerType[headIdx] = stringType;\n  } else if (conv.parseParam.checkType) {\n    return conv.parseRuntime.headerType[headIdx] = dynamicType;\n  } else {\n    return conv.parseRuntime.headerType[headIdx] = stringType;\n  }\n}\n\nfunction numberType(item) {\n  var rtn = parseFloat(item);\n  if (isNaN(rtn)) {\n    return item;\n  }\n  return rtn;\n}\n\nfunction stringType(item: string): string {\n  return item.toString();\n}\n\nfunction dynamicType(item) {\n  var trimed = item.trim();\n  if (trimed === \"\") {\n    return stringType(item);\n  }\n  if (numReg.test(trimed)) {\n    return numberType(item);\n  } else if (trimed.length === 5 && trimed.toLowerCase() === \"false\" || trimed.length === 4 && trimed.toLowerCase() === \"true\") {\n    return booleanType(item);\n  } else if (trimed[0] === \"{\" && trimed[trimed.length - 1] === \"}\" || trimed[0] === \"[\" && trimed[trimed.length - 1] === \"]\") {\n    return jsonType(item);\n  } else {\n    return stringType(item);\n  }\n}\n\nfunction booleanType(item) {\n  var trimed = item.trim();\n  if (trimed.length === 5 && trimed.toLowerCase() === \"false\") {\n    return false;\n  } else {\n    return true;\n  }\n}\n\nfunction jsonType(item) {\n  try {\n    return JSON.parse(item);\n  } catch (e) {\n    return item;\n  }\n}\n"]}

.ts-node/46be5da21...739b703649046edb8805d043fd9d43e23581.js

-"use strict";
-// import {Converter} from "../src/Converter";
-// import csv from "../src";
-// var assert = require("assert");
-// var fs = require("fs");
-// var sandbox = require("sinon").sandbox.create();
-// var file = __dirname + "/data/testData";
-// var trailCommaData = __dirname + "/data/trailingComma";
-// describe("CSV Convert in Background Process", function () {
-//   afterEach(function () {
-//     sandbox.restore();
-//   });
-//   it("should read from a stream", function (done) {
-//     var obj = new Converter({
-//       fork: true
-//     });
-//     var stream = fs.createReadStream(file);
-//     obj.then(function (obj) {
-//       assert.equal(obj.length, 2);
-//       done();
-//     },(err)=>{
-//       console.log(err.toString());
-//     });
-//     stream.pipe(obj);
-//   });
-//   it("should call onNext once a row is parsed.", function (done) {
-//     var obj = new Converter({fork:true});
-//     var stream = fs.createReadStream(file);
-//     var called = false;
-//     obj.subscribe(function (resultRow) {
-//       assert(resultRow);
-//       called = true;
-//     });
-//     obj.on("done", function () {
-//       assert(called);
-//       done();
-//     });
-//     stream.pipe(obj);
-//   });
-//   it("should emit end_parsed message once it is finished.", function (done) {
-//     var obj = new Converter({fork:true});
-//     obj.then(function (result) {
-//       assert(result);
-//       assert(result.length === 2);
-//       assert(result[0].date);
-//       assert(result[0].employee);
-//       assert(result[0].employee.name);
-//       assert(result[0].employee.age);
-//       assert(result[0].employee.number);
-//       assert(result[0].employee.key.length === 2);
-//       assert(result[0].address.length === 2);
-//       done();
-//     });
-//     fs.createReadStream(file).pipe(obj);
-//   });
-//   it("should handle traling comma gracefully", function (done) {
-//     var stream = fs.createReadStream(trailCommaData);
-//     var obj = new Converter({fork:true});
-//     obj.then(function (result) {
-//       assert(result);
-//       assert(result.length > 0);
-//       done();
-//     });
-//     stream.pipe(obj);
-//   });
-//   it("should handle comma in column which is surrounded by qoutes", function (done) {
-//     var testData = __dirname + "/data/dataWithComma";
-//     var rs = fs.createReadStream(testData);
-//     var obj = new Converter({
-//       "quote": "#",
-//       "fork":true
-//     });
-//     obj.then(function (result) {
-//       assert(result[0].col1 === "\"Mini. Sectt");
-//       assert.equal(result[3].col2, "125001,fenvkdsf");
-//       // console.log(result);
-//       done();
-//     });
-//     rs.pipe(obj);
-//   });
-//   it("should be able to convert a csv to column array data", function (done) {
-//     var columArrData = __dirname + "/data/columnArray";
-//     var rs = fs.createReadStream(columArrData);
-//     var result:any = {};
-//     var csvConverter = new Converter({fork:true});
-//     //end_parsed will be emitted once parsing finished
-//     csvConverter.then(function () {
-//       assert(result.TIMESTAMP.length === 5);
-//       done();
-//     });
-//     //record_parsed will be emitted each time a row has been parsed.
-//     csvConverter.subscribe(function (resultRow, rowIndex) {
-//       for (var key in resultRow) {
-//         if (resultRow.hasOwnProperty(key)) {
-//           if (!result[key] || !(result[key] instanceof Array)) {
-//             result[key] = [];
-//           }
-//           result[key][rowIndex] = resultRow[key];
-//         }
-//       }
-//     });
-//     rs.pipe(csvConverter);
-//   });
-//   it("should be able to convert csv string directly", function (done) {
-//     var testData = __dirname + "/data/testData";
-//     var data = fs.readFileSync(testData).toString();
-//     var csvConverter = new Converter({fork:true});
-//     //end_parsed will be emitted once parsing finished
-//     csvConverter.then(function (jsonObj) {
-//       assert.equal(jsonObj.length, 2);
-//     });
-//     csvConverter.fromString(data).then(function (jsonObj) {
-//       assert(jsonObj.length === 2);
-//       done();
-//     });
-//   });
-//   it("should be able to convert csv string with error", function (done) {
-//     var testData = __dirname + "/data/dataWithUnclosedQuotes";
-//     var data = fs.readFileSync(testData).toString();
-//     var csvConverter = new Converter({fork:true});
-//     csvConverter.fromString(data).then(undefined, function (err) {
-//       // console.log(err);
-//       assert(err);
-//       assert.equal(err.err, "unclosed_quote");
-//       done();
-//     });
-//   });
-//   it("should be able to convert csv string without callback provided", function (done) {
-//     var testData = __dirname + "/data/testData";
-//     var data = fs.readFileSync(testData).toString();
-//     var csvConverter = new Converter({fork:true});
-//     //end_parsed will be emitted once parsing finished
-//     csvConverter.then(function (jsonObj) {
-//       assert(jsonObj.length === 2);
-//       done();
-//     });
-//     csvConverter.fromString(data);
-//   });
-//   it("should be able to handle columns with double quotes", function (done) {
-//     var testData = __dirname + "/data/dataWithQoutes";
-//     var data = fs.readFileSync(testData).toString();
-//     var csvConverter = new Converter({fork:true});
-//     csvConverter.fromString(data).then(function (jsonObj) {
-//       assert(jsonObj[0].TIMESTAMP === '13954264"22', JSON.stringify(jsonObj[0].TIMESTAMP));
-//       assert(jsonObj[1].TIMESTAMP === 'abc, def, ccc', JSON.stringify(jsonObj[1].TIMESTAMP));
-//       done();
-//     });
-//   });
-//   it("should be able to handle columns with two double quotes", function (done) {
-//     var testData = __dirname + "/data/twodoublequotes";
-//     var data = fs.readFileSync(testData).toString();
-//     var csvConverter = new Converter({fork:true});
-//     csvConverter.fromString(data).then(function (jsonObj) {
-//       assert.equal(jsonObj[0].title, "\"");
-//       assert.equal(jsonObj[0].data, "xyabcde");
-//       assert.equal(jsonObj[0].uuid, "fejal\"eifa");
-//       assert.equal(jsonObj[0].fieldA, "bnej\"\"falkfe");
-//       assert.equal(jsonObj[0].fieldB, "\"eisjfes\"");
-//       done();
-//     });
-//   });
-//   it("should handle empty csv file", function (done) {
-//     var testData = __dirname + "/data/emptyFile";
-//     var rs = fs.createReadStream(testData);
-//     var csvConverter = new Converter({fork:true});
-//     csvConverter.then(function (jsonObj) {
-//       assert(jsonObj.length === 0);
-//       done();
-//     });
-//     rs.pipe(csvConverter);
-//   });
-//   it("should parse large csv file", function (done) {
-//     var testData = __dirname + "/data/large-csv-sample.csv";
-//     var rs = fs.createReadStream(testData);
-//     var csvConverter = new Converter({fork:true});
-//     var count = 0;
-//     csvConverter.subscribe(function () {
-//       // console.log(arguments);
-//       count++;
-//     });
-//     csvConverter.then(function () {
-//       assert.equal(count, 5290);
-//       done();
-//     });
-//     rs.pipe(csvConverter);
-//   });
-//   it("should parse data and covert to specific types", function (done) {
-//     var testData = __dirname + "/data/dataWithType";
-//     var rs = fs.createReadStream(testData);
-//     var csvConverter = new Converter({
-//       fork:true,
-//       checkType: true,
-//       colParser: {
-//         "column6": "string",
-//         "column7": "string"
-//       }
-//     });
-//     csvConverter.subscribe(function (d) {
-//       assert(typeof d.column1 === "number");
-//       assert(typeof d.column2 === "string");
-//       assert.equal(d["colume4"], "someinvaliddate");
-//       assert(d.column5.hello === "world");
-//       assert(d.column6 === '{"hello":"world"}');
-//       assert(d.column7 === "1234");
-//       assert(d.column8 === "abcd");
-//       assert(d.column9 === true);
-//       assert(d.column10[0] === 23);
-//       assert(d.column10[1] === 31);
-//       assert(d.column11[0].hello === "world");
-//       assert(d["name#!"] === false);
-//     });
-//     csvConverter.on("done", function () {
-//       done();
-//     });
-//     rs.pipe(csvConverter);
-//   });
-//   it("should turn off field type check", function (done) {
-//     var testData = __dirname + "/data/dataWithType";
-//     var rs = fs.createReadStream(testData);
-//     var csvConverter = new Converter({
-//       fork:true,
-//       checkType: false
-//     });
-//     csvConverter.subscribe(function (d) {
-//       assert(typeof d.column1 === "string");
-//       assert(typeof d.column2 === "string");
-//       assert(d["column3"] === "2012-01-01");
-//       assert(d["colume4"] === "someinvaliddate");
-//       assert(d.column5 === '{"hello":"world"}');
-//       assert.equal(d["column6"], '{"hello":"world"}');
-//       assert(d["column7"] === "1234");
-//       assert(d["column8"] === "abcd");
-//       assert(d.column9 === "true");
-//       assert(d.column10[0] === "23");
-//       assert(d.column10[1] === "31");
-//       assert(d["name#!"] === 'false');
-//     });
-//     csvConverter.then(function () {
-//       done();
-//     });
-//     rs.pipe(csvConverter);
-//   });
-//   it("should emit data event correctly", function (done) {
-//     var testData = __dirname + "/data/large-csv-sample.csv";
-//     var csvConverter = new Converter({
-//       fork:true
-//     },{objectMode:true});
-//     var count = 0;
-//     csvConverter.on("data", function (d) {
-//       count++;
-//     });
-//     csvConverter.on("done", function () {
-//       assert.equal(csvConverter.parsedLineNumber, 5290);
-//       done();
-//     });
-//     var rs = fs.createReadStream(testData);
-//     rs.pipe(csvConverter);
-//   });
-//   it("should process column with linebreaks", function (done) {
-//     var testData = __dirname + "/data/lineBreak";
-//     var rs = fs.createReadStream(testData);
-//     var csvConverter = new Converter({
-//       fork:true,
-//       checkType: true
-//     });
-//     csvConverter.subscribe(function (d) {
-//       assert(d.Period === 13);
-//       assert(d["Apparent age"] === "Unknown");
-//       done();
-//     });
-//     rs.pipe(csvConverter);
-//   });
-//   it("be able to ignore empty columns", function (done) {
-//     var testData = __dirname + "/data/dataIgnoreEmpty";
-//     var rs = fs.createReadStream(testData);
-//     var st = rs.pipe(csv({ 
-//       ignoreEmpty: true ,
-//       fork:true
-//     }));
-//     st.then(function (res) {
-//       var j = res[0];
-//       assert(res.length === 3);
-//       assert(j.col2.length === 2);
-//       assert(j.col2[1] === "d3");
-//       assert(j.col4.col3 === undefined);
-//       assert(j.col4.col5 === "world");
-//       assert(res[1].col1 === "d2");
-//       assert(res[2].col1 === "d4");
-//       done();
-//     });
-//   });
-//   it("should allow no header", function (done) {
-//     var testData = __dirname + "/data/noheadercsv";
-//     var rs = fs.createReadStream(testData);
-//     var st = rs.pipe(new Converter({ 
-//       noheader: true,
-//       fork:true
-//     }));
-//     st.then(function (res) {
-//       var j = res[0];
-//       assert(res.length === 5);
-//       assert(j.field1 === "CC102-PDMI-001");
-//       assert(j.field2 === "eClass_5.1.3");
-//       done();
-//     });
-//   });
-//   it("should allow customised header", function (done) {
-//     var testData = __dirname + "/data/noheadercsv";
-//     var rs = fs.createReadStream(testData);
-//     var st = rs.pipe(new Converter({
-//       noheader: true,
-//       headers: ["a", "b"],
-//       fork:true
-//     }));
-//     st.then(function (res) {
-//       var j = res[0];
-//       assert(res.length === 5);
-//       assert(j.a === "CC102-PDMI-001");
-//       assert(j.b === "eClass_5.1.3");
-//       assert(j.field3 === "10/3/2014");
-//       done();
-//     });
-//   });
-//   it("should allow customised header to override existing header", function (done) {
-//     var testData = __dirname + "/data/complexJSONCSV";
-//     var rs = fs.createReadStream(testData);
-//     var st = rs.pipe(new Converter({
-//       headers: [],
-//       fork:true
-//     }));
-//     st.then(function (res) {
-//       var j = res[0];
-//       assert(res.length === 2);
-//       assert(j.field1 === "Food Factory");
-//       assert(j.field2 === "Oscar");
-//       done();
-//     });
-//   });
-//   it("should handle when there is an empty string", function (done) {
-//     var testData = __dirname + "/data/dataWithEmptyString";
-//     var rs = fs.createReadStream(testData);
-//     var st = rs.pipe(new Converter({
-//       noheader: true,
-//       headers: ["a", "b", "c"],
-//       checkType: true,
-//       fork:true
-//     }));
-//     st.then(function (res) {
-//       var j = res[0];
-//       // assert(res.length===2);
-//       assert(j.a === "green");
-//       assert(j.b === 40);
-//       assert.equal(j.c, "");
-//       done();
-//     });
-//   });
-//   it("should detect eol correctly when first chunk is smaller than header row length", function (done) {
-//     var testData = __dirname + "/data/dataNoTrimCRLF";
-//     var rs = fs.createReadStream(testData, { highWaterMark: 3 });
-//     var st = rs.pipe(new Converter({
-//       trim: false,
-//       fork:true
-//     }));
-//     st.then(function (res) {
-//       var j = res[0];
-//       assert(res.length === 2);
-//       assert(j.name === "joe");
-//       assert(j.age === "20");
-//       assert.equal(res[1].name, "sam");
-//       assert.equal(res[1].age, "30");
-//       done();
-//     });
-//   });
-//   it("should detect eol correctly when first chunk ends in middle of CRLF line break", function (done) {
-//     var testData = __dirname + "/data/dataNoTrimCRLF";
-//     var rs = fs.createReadStream(testData, { highWaterMark: 9 });
-//     var st = rs.pipe(new Converter({
-//       trim: false,
-//       fork:true
-//     }));
-//     st.then(function (res) {
-//       var j = res[0];
-//       assert(res.length === 2);
-//       assert(j.name === "joe");
-//       assert(j.age === "20");
-//       assert.equal(res[1].name, "sam");
-//       assert.equal(res[1].age, "30");
-//       done();
-//     });
-//   });
-//   it("should emit eol event when line ending is detected as CRLF", function (done) {
-//     var testData = __dirname + "/data/dataNoTrimCRLF";
-//     var rs = fs.createReadStream(testData);
-//     var st = rs.pipe(new Converter({
-//       fork:true
-//     }));
-//     var eolCallback = sandbox.spy(function (eol) {
-//       assert.equal(eol, "\r\n");
-//     });
-//     st.on("eol", eolCallback);
-//     st.then(function () {
-//       assert.equal(eolCallback.callCount, 1, 'should emit eol event once');
-//       done();
-//     })
-//   });
-//   it("should emit eol event when line ending is detected as LF", function (done) {
-//     var testData = __dirname + "/data/columnArray";
-//     var rs = fs.createReadStream(testData);
-//     var st = rs.pipe(new Converter({
-//       fork:true
-//     }));
-//     var eolCallback = sandbox.spy(function (eol) {
-//       assert.equal(eol, "\n");
-//     });
-//     st.on("eol", eolCallback);
-//     st.then(function () {
-//       assert.equal(eolCallback.callCount, 1, 'should emit eol event once');
-//       done();
-//     })
-//   });
-//   it("should remove the Byte Order Mark (BOM) from input", function (done) {
-//     var testData = __dirname + "/data/dataNoTrimBOM";
-//     var rs = fs.createReadStream(testData);
-//     var st = rs.pipe(new Converter({
-//       trim: false,
-//       fork:true
-//     }));
-//     st.then( function (res) {
-//       var j = res[0];
-//       assert(res.length===2);
-//       assert(j.name === "joe");
-//       assert(j.age === "20");
-//       done();
-//     });
-//   });
-//   it("should set output as csv", function (done) {
-//     var testData = __dirname + "/data/complexJSONCSV";
-//     var rs = fs.createReadStream(testData);
-//     var numOfRow = 0;
-//     csv({ output: "csv",fork:true })
-//       .fromStream(rs)
-//       .subscribe(function (row, idx) {
-//         numOfRow++;
-//         assert(row);
-//         assert(idx >= 0);
-//       })
-//       .on("done", function (error) {
-//         assert(!error);
-//         assert.equal(2, numOfRow);
-//         assert(numOfRow !== 0);
-//         done();
-//       });
-//   });
-//   it("should process long header", function (done) {
-//     var testData = __dirname + "/data/longHeader";
-//     var rs = fs.createReadStream(testData, { highWaterMark: 100 });
-//     var numOfRow = 0;
-//     var numOfJson = 0;
-//     csv({fork:true}, { highWaterMark: 100 })
-//       .fromStream(rs)
-//       .subscribe(function (res, idx) {
-//         numOfJson++;
-//         assert.equal(res.Date, '8/26/16');
-//         assert(idx >= 0);
-//       })
-//       .on("done", function () {
-//         assert(numOfJson === 1);
-//         done();
-//       });
-//   });
-//   it("should parse #139", function (done) {
-//     var rs = fs.createReadStream(__dirname + "/data/data#139");
-//     csv({fork:true})
-//       .fromStream(rs)
-//       .then(function (res) {
-//         assert.equal(res[1].field3, "9001009395 9001009990");
-//         done();
-//       });
-//   });
-//   it("should ignore column", function (done) {
-//     var rs = fs.createReadStream(__dirname + "/data/dataWithQoutes");
-//     var headerEmitted = false;
-//     csv({
-//       ignoreColumns: /TIMESTAMP/,
-//       fork:true
-//     })
-//       .fromStream(rs)
-//       .on("header", function (header) {
-//         assert.equal(header.indexOf("TIMESTAMP"), -1);
-//         assert.equal(header.indexOf("UPDATE"), 0);
-//         if (headerEmitted) {
-//           throw ("header event should only happen once")
-//         }
-//         headerEmitted = true;
-//       })
-//       // .on("csv", function (row, idx) {
-//       //   if (!headerEmitted) {
-//       //     throw ("header should be emitted before any data events");
-//       //   }
-//       //   assert(idx >= 0);
-//       //   if (idx === 1) {
-//       //     assert.equal(row[0], "n");
-//       //   }
-//       // })
-//       .subscribe(function (j, idx) {
-//         // console.log(j);
-//         assert(!j.TIMESTAMP);
-//         assert(idx >= 0);
-//       })
-//       .on("done", function (err) {
-//         assert(!err);
-//         assert(headerEmitted);
-//         done();
-//       });
-//   });
-//   it("should include column", function (done) {
-//     var rs = fs.createReadStream(__dirname + "/data/dataWithQoutes");
-//     csv({
-//       includeColumns: /TIMESTAMP/,
-//       fork:true
-//     })
-//       .fromStream(rs)
-//       .on("header", function (header) {
-//         assert.equal(header.indexOf("TIMESTAMP"), 0);
-//         assert.equal(header.indexOf("UPDATE"), -1);
-//         assert.equal(header.length, 1);
-//       })
-//       .subscribe(function (j, idx) {
-//         assert(idx >= 0);
-//         if (idx === 1) {
-//           assert.equal(j.TIMESTAMP, "abc, def, ccc");
-//         }
-//         assert(!j.UID)
-//         assert(!j['BYTES SENT'])
-//       })
-//       .on("done", function () {
-//         done();
-//       });
-//   });
-//   it("should allow headers and include columns to be given as reference to the same var", function (done) {
-//     var rs = fs.createReadStream(__dirname + "/data/complexJSONCSV");
-//     var headers = [
-//       'first',
-//       'second',
-//       'third',
-//     ];
-//     var expected = headers;
-//     csv({
-//       headers: headers,
-//       includeColumns: /(first|second|third)/,
-//       fork:true
-//     })
-//       .fromStream(rs)
-//       .on("header", function (header) {
-//         expected.forEach(function (value, index) {
-//           assert.equal(header.indexOf(value), index);
-//         });
-//       })
-//       .subscribe(function (j, idx) {
-//         assert(idx >= 0);
-//         assert.equal(expected.length, Object.keys(j).length);
-//         expected.forEach(function (attribute) {
-//           assert(j.hasOwnProperty(attribute));
-//         });
-//       })
-//       .on("done", function () {
-//         done();
-//       });
-//   });
-//   it("should leave provided params objects unmutated", function() {
-//     var rs = fs.createReadStream(__dirname + "/data/complexJSONCSV");
-//     var includeColumns = [
-//       'fieldA.title',
-//       'description',
-//     ];
-//     return csv({
-//       includeColumns: /(fieldA\.title|description)/,
-//       fork:true
-//     })
-//       .fromStream(rs)
-//       .on("json", function(j, idx) {
-//         assert(idx >= 0);
-//       })
-//       .on("header", function(header) {
-//         includeColumns.forEach(function (value, index) {
-//           assert.equal(index, header.indexOf(value));
-//         });
-//       })
-//   });
-//   it("should accept pipe as quote", function (done) {
-//     csv({
-//       quote: "|",
-//       output: "csv",
-//       "fork":true
-//     })
-//       .fromFile(__dirname + "/data/pipeAsQuote")
-//       .subscribe(function (csv) {
-//         assert.equal(csv[2], "blahhh, blah");
-//       })
-//       .on('done', function () {
-//         done()
-//       });
-//   })
-//   it("should allow async subscribe function", () => {
-//     return csv({ trim: true,fork:true })
-//       .fromString(`a,b,c
-//     1,2,3
-//     4,5,6`)
-//       .subscribe((d) => {
-//         return new Promise((resolve, reject) => {
-//           setTimeout(() => {
-//             d.a = 10;
-//             resolve();
-//           }, 20);
-//         })
-//       })
-//       .then((d) => {
-//         assert.equal(d[0].a, 10);
-//         assert.equal(d[1].a, 10);
-//       })
-//   })
-//   it("should omit a column", () => {
-//     return csv({
-//       colParser: {
-//         "a": "omit"
-//       },
-//       fork:true
-//     })
-//       .fromString(`a,b,c
-//   1,2,3
-//   fefe,5,6`)
-//       .then((d) => {
-//         assert.strictEqual(d[0].a, undefined);
-//         assert.equal(d[1].a, undefined);
-//       })
-//   })
-// });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/test/testCSVConverter.fork.ts","sources":["/Users/kxiang/work/projects/csv2json/test/testCSVConverter.fork.ts"],"names":[],"mappings":"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","sourcesContent":["// import {Converter} from \"../src/Converter\";\n// import csv from \"../src\";\n// var assert = require(\"assert\");\n// var fs = require(\"fs\");\n// var sandbox = require(\"sinon\").sandbox.create();\n// var file = __dirname + \"/data/testData\";\n// var trailCommaData = __dirname + \"/data/trailingComma\";\n// describe(\"CSV Convert in Background Process\", function () {\n//   afterEach(function () {\n//     sandbox.restore();\n//   });\n\n\n//   it(\"should read from a stream\", function (done) {\n//     var obj = new Converter({\n//       fork: true\n//     });\n//     var stream = fs.createReadStream(file);\n//     obj.then(function (obj) {\n//       assert.equal(obj.length, 2);\n//       done();\n//     },(err)=>{\n//       console.log(err.toString());\n//     });\n//     stream.pipe(obj);\n//   });\n\n//   it(\"should call onNext once a row is parsed.\", function (done) {\n//     var obj = new Converter({fork:true});\n//     var stream = fs.createReadStream(file);\n//     var called = false;\n//     obj.subscribe(function (resultRow) {\n//       assert(resultRow);\n//       called = true;\n//     });\n//     obj.on(\"done\", function () {\n//       assert(called);\n//       done();\n//     });\n//     stream.pipe(obj);\n//   });\n\n//   it(\"should emit end_parsed message once it is finished.\", function (done) {\n//     var obj = new Converter({fork:true});\n//     obj.then(function (result) {\n//       assert(result);\n//       assert(result.length === 2);\n//       assert(result[0].date);\n//       assert(result[0].employee);\n//       assert(result[0].employee.name);\n//       assert(result[0].employee.age);\n//       assert(result[0].employee.number);\n//       assert(result[0].employee.key.length === 2);\n//       assert(result[0].address.length === 2);\n//       done();\n//     });\n//     fs.createReadStream(file).pipe(obj);\n//   });\n\n//   it(\"should handle traling comma gracefully\", function (done) {\n//     var stream = fs.createReadStream(trailCommaData);\n//     var obj = new Converter({fork:true});\n//     obj.then(function (result) {\n//       assert(result);\n//       assert(result.length > 0);\n//       done();\n//     });\n//     stream.pipe(obj);\n//   });\n\n//   it(\"should handle comma in column which is surrounded by qoutes\", function (done) {\n//     var testData = __dirname + \"/data/dataWithComma\";\n//     var rs = fs.createReadStream(testData);\n//     var obj = new Converter({\n//       \"quote\": \"#\",\n//       \"fork\":true\n//     });\n//     obj.then(function (result) {\n//       assert(result[0].col1 === \"\\\"Mini. Sectt\");\n//       assert.equal(result[3].col2, \"125001,fenvkdsf\");\n//       // console.log(result);\n//       done();\n//     });\n//     rs.pipe(obj);\n//   });\n\n//   it(\"should be able to convert a csv to column array data\", function (done) {\n//     var columArrData = __dirname + \"/data/columnArray\";\n//     var rs = fs.createReadStream(columArrData);\n//     var result:any = {};\n//     var csvConverter = new Converter({fork:true});\n//     //end_parsed will be emitted once parsing finished\n//     csvConverter.then(function () {\n//       assert(result.TIMESTAMP.length === 5);\n//       done();\n//     });\n\n//     //record_parsed will be emitted each time a row has been parsed.\n//     csvConverter.subscribe(function (resultRow, rowIndex) {\n//       for (var key in resultRow) {\n//         if (resultRow.hasOwnProperty(key)) {\n//           if (!result[key] || !(result[key] instanceof Array)) {\n//             result[key] = [];\n//           }\n//           result[key][rowIndex] = resultRow[key];\n//         }\n//       }\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should be able to convert csv string directly\", function (done) {\n//     var testData = __dirname + \"/data/testData\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     //end_parsed will be emitted once parsing finished\n//     csvConverter.then(function (jsonObj) {\n//       assert.equal(jsonObj.length, 2);\n//     });\n//     csvConverter.fromString(data).then(function (jsonObj) {\n//       assert(jsonObj.length === 2);\n//       done();\n//     });\n//   });\n\n//   it(\"should be able to convert csv string with error\", function (done) {\n//     var testData = __dirname + \"/data/dataWithUnclosedQuotes\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     csvConverter.fromString(data).then(undefined, function (err) {\n//       // console.log(err);\n//       assert(err);\n//       assert.equal(err.err, \"unclosed_quote\");\n//       done();\n//     });\n//   });\n\n//   it(\"should be able to convert csv string without callback provided\", function (done) {\n//     var testData = __dirname + \"/data/testData\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     //end_parsed will be emitted once parsing finished\n//     csvConverter.then(function (jsonObj) {\n//       assert(jsonObj.length === 2);\n//       done();\n//     });\n//     csvConverter.fromString(data);\n//   });\n\n//   it(\"should be able to handle columns with double quotes\", function (done) {\n//     var testData = __dirname + \"/data/dataWithQoutes\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     csvConverter.fromString(data).then(function (jsonObj) {\n//       assert(jsonObj[0].TIMESTAMP === '13954264\"22', JSON.stringify(jsonObj[0].TIMESTAMP));\n\n//       assert(jsonObj[1].TIMESTAMP === 'abc, def, ccc', JSON.stringify(jsonObj[1].TIMESTAMP));\n//       done();\n//     });\n//   });\n\n//   it(\"should be able to handle columns with two double quotes\", function (done) {\n//     var testData = __dirname + \"/data/twodoublequotes\";\n//     var data = fs.readFileSync(testData).toString();\n//     var csvConverter = new Converter({fork:true});\n//     csvConverter.fromString(data).then(function (jsonObj) {\n//       assert.equal(jsonObj[0].title, \"\\\"\");\n//       assert.equal(jsonObj[0].data, \"xyabcde\");\n//       assert.equal(jsonObj[0].uuid, \"fejal\\\"eifa\");\n//       assert.equal(jsonObj[0].fieldA, \"bnej\\\"\\\"falkfe\");\n//       assert.equal(jsonObj[0].fieldB, \"\\\"eisjfes\\\"\");\n//       done();\n//     });\n//   });\n\n//   it(\"should handle empty csv file\", function (done) {\n//     var testData = __dirname + \"/data/emptyFile\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({fork:true});\n//     csvConverter.then(function (jsonObj) {\n//       assert(jsonObj.length === 0);\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should parse large csv file\", function (done) {\n//     var testData = __dirname + \"/data/large-csv-sample.csv\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({fork:true});\n//     var count = 0;\n//     csvConverter.subscribe(function () {\n//       // console.log(arguments);\n//       count++;\n//     });\n//     csvConverter.then(function () {\n//       assert.equal(count, 5290);\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should parse data and covert to specific types\", function (done) {\n//     var testData = __dirname + \"/data/dataWithType\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({\n//       fork:true,\n//       checkType: true,\n//       colParser: {\n//         \"column6\": \"string\",\n//         \"column7\": \"string\"\n//       }\n//     });\n//     csvConverter.subscribe(function (d) {\n//       assert(typeof d.column1 === \"number\");\n//       assert(typeof d.column2 === \"string\");\n//       assert.equal(d[\"colume4\"], \"someinvaliddate\");\n//       assert(d.column5.hello === \"world\");\n//       assert(d.column6 === '{\"hello\":\"world\"}');\n//       assert(d.column7 === \"1234\");\n//       assert(d.column8 === \"abcd\");\n//       assert(d.column9 === true);\n//       assert(d.column10[0] === 23);\n//       assert(d.column10[1] === 31);\n//       assert(d.column11[0].hello === \"world\");\n//       assert(d[\"name#!\"] === false);\n//     });\n//     csvConverter.on(\"done\", function () {\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should turn off field type check\", function (done) {\n//     var testData = __dirname + \"/data/dataWithType\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({\n//       fork:true,\n//       checkType: false\n//     });\n//     csvConverter.subscribe(function (d) {\n//       assert(typeof d.column1 === \"string\");\n//       assert(typeof d.column2 === \"string\");\n//       assert(d[\"column3\"] === \"2012-01-01\");\n//       assert(d[\"colume4\"] === \"someinvaliddate\");\n//       assert(d.column5 === '{\"hello\":\"world\"}');\n//       assert.equal(d[\"column6\"], '{\"hello\":\"world\"}');\n//       assert(d[\"column7\"] === \"1234\");\n//       assert(d[\"column8\"] === \"abcd\");\n//       assert(d.column9 === \"true\");\n//       assert(d.column10[0] === \"23\");\n//       assert(d.column10[1] === \"31\");\n//       assert(d[\"name#!\"] === 'false');\n//     });\n//     csvConverter.then(function () {\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should emit data event correctly\", function (done) {\n//     var testData = __dirname + \"/data/large-csv-sample.csv\";\n\n//     var csvConverter = new Converter({\n//       fork:true\n//     },{objectMode:true});\n//     var count = 0;\n//     csvConverter.on(\"data\", function (d) {\n//       count++;\n//     });\n//     csvConverter.on(\"done\", function () {\n//       assert.equal(csvConverter.parsedLineNumber, 5290);\n//       done();\n//     });\n//     var rs = fs.createReadStream(testData);\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"should process column with linebreaks\", function (done) {\n//     var testData = __dirname + \"/data/lineBreak\";\n//     var rs = fs.createReadStream(testData);\n//     var csvConverter = new Converter({\n//       fork:true,\n//       checkType: true\n//     });\n//     csvConverter.subscribe(function (d) {\n//       assert(d.Period === 13);\n//       assert(d[\"Apparent age\"] === \"Unknown\");\n//       done();\n//     });\n//     rs.pipe(csvConverter);\n//   });\n\n//   it(\"be able to ignore empty columns\", function (done) {\n//     var testData = __dirname + \"/data/dataIgnoreEmpty\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(csv({ \n//       ignoreEmpty: true ,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 3);\n//       assert(j.col2.length === 2);\n//       assert(j.col2[1] === \"d3\");\n//       assert(j.col4.col3 === undefined);\n//       assert(j.col4.col5 === \"world\");\n//       assert(res[1].col1 === \"d2\");\n//       assert(res[2].col1 === \"d4\");\n//       done();\n//     });\n//   });\n\n//   it(\"should allow no header\", function (done) {\n//     var testData = __dirname + \"/data/noheadercsv\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({ \n//       noheader: true,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 5);\n//       assert(j.field1 === \"CC102-PDMI-001\");\n//       assert(j.field2 === \"eClass_5.1.3\");\n//       done();\n//     });\n//   });\n\n//   it(\"should allow customised header\", function (done) {\n//     var testData = __dirname + \"/data/noheadercsv\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({\n//       noheader: true,\n//       headers: [\"a\", \"b\"],\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 5);\n//       assert(j.a === \"CC102-PDMI-001\");\n//       assert(j.b === \"eClass_5.1.3\");\n//       assert(j.field3 === \"10/3/2014\");\n//       done();\n//     });\n//   });\n\n//   it(\"should allow customised header to override existing header\", function (done) {\n//     var testData = __dirname + \"/data/complexJSONCSV\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({\n//       headers: [],\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 2);\n//       assert(j.field1 === \"Food Factory\");\n//       assert(j.field2 === \"Oscar\");\n//       done();\n//     });\n//   });\n\n//   it(\"should handle when there is an empty string\", function (done) {\n//     var testData = __dirname + \"/data/dataWithEmptyString\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({\n//       noheader: true,\n//       headers: [\"a\", \"b\", \"c\"],\n//       checkType: true,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n\n//       // assert(res.length===2);\n//       assert(j.a === \"green\");\n//       assert(j.b === 40);\n//       assert.equal(j.c, \"\");\n//       done();\n//     });\n//   });\n\n//   it(\"should detect eol correctly when first chunk is smaller than header row length\", function (done) {\n//     var testData = __dirname + \"/data/dataNoTrimCRLF\";\n//     var rs = fs.createReadStream(testData, { highWaterMark: 3 });\n\n//     var st = rs.pipe(new Converter({\n//       trim: false,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 2);\n//       assert(j.name === \"joe\");\n//       assert(j.age === \"20\");\n//       assert.equal(res[1].name, \"sam\");\n//       assert.equal(res[1].age, \"30\");\n//       done();\n//     });\n//   });\n\n//   it(\"should detect eol correctly when first chunk ends in middle of CRLF line break\", function (done) {\n//     var testData = __dirname + \"/data/dataNoTrimCRLF\";\n//     var rs = fs.createReadStream(testData, { highWaterMark: 9 });\n\n//     var st = rs.pipe(new Converter({\n//       trim: false,\n//       fork:true\n//     }));\n//     st.then(function (res) {\n//       var j = res[0];\n//       assert(res.length === 2);\n//       assert(j.name === \"joe\");\n//       assert(j.age === \"20\");\n//       assert.equal(res[1].name, \"sam\");\n//       assert.equal(res[1].age, \"30\");\n//       done();\n//     });\n//   });\n\n//   it(\"should emit eol event when line ending is detected as CRLF\", function (done) {\n//     var testData = __dirname + \"/data/dataNoTrimCRLF\";\n//     var rs = fs.createReadStream(testData);\n\n//     var st = rs.pipe(new Converter({\n//       fork:true\n//     }));\n//     var eolCallback = sandbox.spy(function (eol) {\n//       assert.equal(eol, \"\\r\\n\");\n//     });\n//     st.on(\"eol\", eolCallback);\n//     st.then(function () {\n//       assert.equal(eolCallback.callCount, 1, 'should emit eol event once');\n//       done();\n//     })\n//   });\n\n//   it(\"should emit eol event when line ending is detected as LF\", function (done) {\n//     var testData = __dirname + \"/data/columnArray\";\n//     var rs = fs.createReadStream(testData);\n\n//     var st = rs.pipe(new Converter({\n//       fork:true\n//     }));\n//     var eolCallback = sandbox.spy(function (eol) {\n//       assert.equal(eol, \"\\n\");\n//     });\n//     st.on(\"eol\", eolCallback);\n//     st.then(function () {\n//       assert.equal(eolCallback.callCount, 1, 'should emit eol event once');\n//       done();\n//     })\n//   });\n\n//   it(\"should remove the Byte Order Mark (BOM) from input\", function (done) {\n//     var testData = __dirname + \"/data/dataNoTrimBOM\";\n//     var rs = fs.createReadStream(testData);\n//     var st = rs.pipe(new Converter({\n//       trim: false,\n//       fork:true\n//     }));\n//     st.then( function (res) {\n//       var j = res[0];\n\n//       assert(res.length===2);\n//       assert(j.name === \"joe\");\n//       assert(j.age === \"20\");\n//       done();\n//     });\n//   });\n\n//   it(\"should set output as csv\", function (done) {\n//     var testData = __dirname + \"/data/complexJSONCSV\";\n//     var rs = fs.createReadStream(testData);\n//     var numOfRow = 0;\n//     csv({ output: \"csv\",fork:true })\n//       .fromStream(rs)\n//       .subscribe(function (row, idx) {\n//         numOfRow++;\n//         assert(row);\n//         assert(idx >= 0);\n//       })\n\n//       .on(\"done\", function (error) {\n//         assert(!error);\n//         assert.equal(2, numOfRow);\n//         assert(numOfRow !== 0);\n//         done();\n//       });\n//   });\n//   it(\"should process long header\", function (done) {\n//     var testData = __dirname + \"/data/longHeader\";\n//     var rs = fs.createReadStream(testData, { highWaterMark: 100 });\n//     var numOfRow = 0;\n//     var numOfJson = 0;\n//     csv({fork:true}, { highWaterMark: 100 })\n//       .fromStream(rs)\n//       .subscribe(function (res, idx) {\n//         numOfJson++;\n//         assert.equal(res.Date, '8/26/16');\n//         assert(idx >= 0);\n//       })\n//       .on(\"done\", function () {\n//         assert(numOfJson === 1);\n//         done();\n//       });\n//   });\n//   it(\"should parse #139\", function (done) {\n//     var rs = fs.createReadStream(__dirname + \"/data/data#139\");\n//     csv({fork:true})\n//       .fromStream(rs)\n//       .then(function (res) {\n//         assert.equal(res[1].field3, \"9001009395 9001009990\");\n//         done();\n//       });\n//   });\n\n//   it(\"should ignore column\", function (done) {\n//     var rs = fs.createReadStream(__dirname + \"/data/dataWithQoutes\");\n//     var headerEmitted = false;\n//     csv({\n//       ignoreColumns: /TIMESTAMP/,\n//       fork:true\n//     })\n//       .fromStream(rs)\n//       .on(\"header\", function (header) {\n//         assert.equal(header.indexOf(\"TIMESTAMP\"), -1);\n//         assert.equal(header.indexOf(\"UPDATE\"), 0);\n//         if (headerEmitted) {\n//           throw (\"header event should only happen once\")\n//         }\n//         headerEmitted = true;\n//       })\n//       // .on(\"csv\", function (row, idx) {\n//       //   if (!headerEmitted) {\n//       //     throw (\"header should be emitted before any data events\");\n//       //   }\n//       //   assert(idx >= 0);\n//       //   if (idx === 1) {\n//       //     assert.equal(row[0], \"n\");\n//       //   }\n//       // })\n//       .subscribe(function (j, idx) {\n//         // console.log(j);\n//         assert(!j.TIMESTAMP);\n//         assert(idx >= 0);\n//       })\n//       .on(\"done\", function (err) {\n//         assert(!err);\n//         assert(headerEmitted);\n//         done();\n//       });\n//   });\n//   it(\"should include column\", function (done) {\n//     var rs = fs.createReadStream(__dirname + \"/data/dataWithQoutes\");\n//     csv({\n//       includeColumns: /TIMESTAMP/,\n//       fork:true\n//     })\n//       .fromStream(rs)\n//       .on(\"header\", function (header) {\n//         assert.equal(header.indexOf(\"TIMESTAMP\"), 0);\n//         assert.equal(header.indexOf(\"UPDATE\"), -1);\n//         assert.equal(header.length, 1);\n//       })\n//       .subscribe(function (j, idx) {\n//         assert(idx >= 0);\n//         if (idx === 1) {\n//           assert.equal(j.TIMESTAMP, \"abc, def, ccc\");\n//         }\n//         assert(!j.UID)\n//         assert(!j['BYTES SENT'])\n//       })\n//       .on(\"done\", function () {\n//         done();\n//       });\n//   });\n//   it(\"should allow headers and include columns to be given as reference to the same var\", function (done) {\n//     var rs = fs.createReadStream(__dirname + \"/data/complexJSONCSV\");\n//     var headers = [\n//       'first',\n//       'second',\n//       'third',\n//     ];\n\n//     var expected = headers;\n\n//     csv({\n//       headers: headers,\n//       includeColumns: /(first|second|third)/,\n//       fork:true\n//     })\n//       .fromStream(rs)\n//       .on(\"header\", function (header) {\n//         expected.forEach(function (value, index) {\n//           assert.equal(header.indexOf(value), index);\n//         });\n//       })\n//       .subscribe(function (j, idx) {\n//         assert(idx >= 0);\n//         assert.equal(expected.length, Object.keys(j).length);\n//         expected.forEach(function (attribute) {\n//           assert(j.hasOwnProperty(attribute));\n//         });\n//       })\n//       .on(\"done\", function () {\n//         done();\n//       });\n//   });\n\n//   it(\"should leave provided params objects unmutated\", function() {\n//     var rs = fs.createReadStream(__dirname + \"/data/complexJSONCSV\");\n//     var includeColumns = [\n//       'fieldA.title',\n//       'description',\n//     ];\n\n\n//     return csv({\n//       includeColumns: /(fieldA\\.title|description)/,\n//       fork:true\n//     })\n//       .fromStream(rs)\n//       .on(\"json\", function(j, idx) {\n//         assert(idx >= 0);\n//       })\n//       .on(\"header\", function(header) {\n//         includeColumns.forEach(function (value, index) {\n//           assert.equal(index, header.indexOf(value));\n//         });\n//       })\n//   });\n//   it(\"should accept pipe as quote\", function (done) {\n//     csv({\n//       quote: \"|\",\n//       output: \"csv\",\n//       \"fork\":true\n//     })\n//       .fromFile(__dirname + \"/data/pipeAsQuote\")\n//       .subscribe(function (csv) {\n//         assert.equal(csv[2], \"blahhh, blah\");\n//       })\n//       .on('done', function () {\n//         done()\n//       });\n//   })\n//   it(\"should allow async subscribe function\", () => {\n//     return csv({ trim: true,fork:true })\n//       .fromString(`a,b,c\n//     1,2,3\n//     4,5,6`)\n//       .subscribe((d) => {\n//         return new Promise((resolve, reject) => {\n//           setTimeout(() => {\n//             d.a = 10;\n//             resolve();\n//           }, 20);\n//         })\n//       })\n//       .then((d) => {\n//         assert.equal(d[0].a, 10);\n//         assert.equal(d[1].a, 10);\n//       })\n//   })\n//   it(\"should omit a column\", () => {\n//     return csv({\n//       colParser: {\n//         \"a\": \"omit\"\n//       },\n//       fork:true\n//     })\n//       .fromString(`a,b,c\n//   1,2,3\n//   fefe,5,6`)\n//       .then((d) => {\n//         assert.strictEqual(d[0].a, undefined);\n//         assert.equal(d[1].a, undefined);\n//       })\n//   })\n  \n// });\n"]}

.ts-node/46be5da21...af68e9e74f24d69965986f1dfd58764d8f18.js

-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var getEol_1 = __importDefault(require("./getEol"));
-var util_1 = require("./util");
-var defaulDelimiters = [",", "|", "\t", ";", ":"];
-var RowSplit = /** @class */ (function () {
-    function RowSplit(conv) {
-        this.conv = conv;
-        this.cachedRegExp = {};
-        this.delimiterEmitted = false;
-        this._needEmitDelimiter = undefined;
-        this.quote = conv.parseParam.quote;
-        this.trim = conv.parseParam.trim;
-        this.escape = conv.parseParam.escape;
-    }
-    Object.defineProperty(RowSplit.prototype, "needEmitDelimiter", {
-        get: function () {
-            if (this._needEmitDelimiter === undefined) {
-                this._needEmitDelimiter = this.conv.listeners("delimiter").length > 0;
-            }
-            return this._needEmitDelimiter;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    RowSplit.prototype.parse = function (fileline) {
-        if (fileline.length === 0 || (this.conv.parseParam.ignoreEmpty && fileline.trim().length === 0)) {
-            return { cells: [], closed: true };
-        }
-        var quote = this.quote;
-        var trim = this.trim;
-        var escape = this.escape;
-        if (this.conv.parseRuntime.delimiter instanceof Array || this.conv.parseRuntime.delimiter.toLowerCase() === "auto") {
-            this.conv.parseRuntime.delimiter = this.getDelimiter(fileline);
-        }
-        if (this.needEmitDelimiter && !this.delimiterEmitted) {
-            this.conv.emit("delimiter", this.conv.parseRuntime.delimiter);
-            this.delimiterEmitted = true;
-        }
-        var delimiter = this.conv.parseRuntime.delimiter;
-        var rowArr = fileline.split(delimiter);
-        if (quote === "off") {
-            if (trim) {
-                for (var i = 0; i < rowArr.length; i++) {
-                    rowArr[i] = rowArr[i].trim();
-                }
-            }
-            return { cells: rowArr, closed: true };
-        }
-        else {
-            return this.toCSVRow(rowArr, trim, quote, delimiter);
-        }
-    };
-    RowSplit.prototype.toCSVRow = function (rowArr, trim, quote, delimiter) {
-        var row = [];
-        var inquote = false;
-        var quoteBuff = '';
-        for (var i = 0, rowLen = rowArr.length; i < rowLen; i++) {
-            var e = rowArr[i];
-            if (!inquote && trim) {
-                e = util_1.trimLeft(e);
-            }
-            var len = e.length;
-            if (!inquote) {
-                if (len === 2 && e === this.quote + this.quote) {
-                    row.push("");
-                    continue;
-                }
-                else if (this.isQuoteOpen(e)) { //quote open
-                    e = e.substr(1);
-                    if (this.isQuoteClose(e)) { //quote close
-                        e = e.substring(0, e.lastIndexOf(quote));
-                        e = this.escapeQuote(e);
-                        row.push(e);
-                        continue;
-                    }
-                    else if (e.indexOf(quote) !== -1) {
-                        var count = 0;
-                        for (var _i = 0, e_1 = e; _i < e_1.length; _i++) {
-                            var c = e_1[_i];
-                            if (c === quote) {
-                                count++;
-                            }
-                        }
-                        if (count % 2 === 1) {
-                            if (trim) {
-                                e = util_1.trimRight(e);
-                            }
-                            row.push(quote + e);
-                            continue;
-                        }
-                        else {
-                            inquote = true;
-                            quoteBuff += e;
-                            continue;
-                        }
-                    }
-                    else {
-                        inquote = true;
-                        quoteBuff += e;
-                        continue;
-                    }
-                }
-                else {
-                    if (trim) {
-                        e = util_1.trimRight(e);
-                    }
-                    row.push(e);
-                    continue;
-                }
-            }
-            else { //previous quote not closed
-                if (this.isQuoteClose(e)) { //close double quote
-                    inquote = false;
-                    e = e.substr(0, len - 1);
-                    quoteBuff += delimiter + e;
-                    quoteBuff = this.escapeQuote(quoteBuff);
-                    if (trim) {
-                        quoteBuff = util_1.trimRight(quoteBuff);
-                    }
-                    row.push(quoteBuff);
-                    quoteBuff = "";
-                }
-                else {
-                    quoteBuff += delimiter + e;
-                }
-            }
-        }
-        // if (!inquote && param._needFilterRow) {
-        //   row = filterRow(row, param);
-        // }
-        return { cells: row, closed: !inquote };
-    };
-    RowSplit.prototype.getDelimiter = function (fileline) {
-        var checker;
-        if (this.conv.parseParam.delimiter === "auto") {
-            checker = defaulDelimiters;
-        }
-        else if (this.conv.parseParam.delimiter instanceof Array) {
-            checker = this.conv.parseParam.delimiter;
-        }
-        else {
-            return this.conv.parseParam.delimiter;
-        }
-        var count = 0;
-        var rtn = ",";
-        checker.forEach(function (delim) {
-            var delimCount = fileline.split(delim).length;
-            if (delimCount > count) {
-                rtn = delim;
-                count = delimCount;
-            }
-        });
-        return rtn;
-    };
-    RowSplit.prototype.isQuoteOpen = function (str) {
-        var quote = this.quote;
-        var escape = this.escape;
-        return str[0] === quote && (str[1] !== quote ||
-            str[1] === escape && (str[2] === quote || str.length === 2));
-    };
-    RowSplit.prototype.isQuoteClose = function (str) {
-        var quote = this.quote;
-        var escape = this.escape;
-        if (this.conv.parseParam.trim) {
-            str = util_1.trimRight(str);
-        }
-        var count = 0;
-        var idx = str.length - 1;
-        while (str[idx] === quote || str[idx] === escape) {
-            idx--;
-            count++;
-        }
-        return count % 2 !== 0;
-    };
-    // private twoDoubleQuote(str: string): string {
-    //   var twoQuote = this.quote + this.quote;
-    //   var curIndex = -1;
-    //   while ((curIndex = str.indexOf(twoQuote, curIndex)) > -1) {
-    //     str = str.substring(0, curIndex) + str.substring(++curIndex);
-    //   }
-    //   return str;
-    // }
-    RowSplit.prototype.escapeQuote = function (segment) {
-        var key = "es|" + this.quote + "|" + this.escape;
-        if (this.cachedRegExp[key] === undefined) {
-            this.cachedRegExp[key] = new RegExp('\\' + this.escape + '\\' + this.quote, 'g');
-        }
-        var regExp = this.cachedRegExp[key];
-        // console.log(regExp,segment);
-        return segment.replace(regExp, this.quote);
-    };
-    RowSplit.prototype.parseMultiLines = function (lines) {
-        var csvLines = [];
-        var left = "";
-        while (lines.length) {
-            var line = left + lines.shift();
-            var row = this.parse(line);
-            if (row.cells.length === 0 && this.conv.parseParam.ignoreEmpty) {
-                continue;
-            }
-            if (row.closed || this.conv.parseParam.alwaysSplitAtEOL) {
-                if (this.conv.parseRuntime.selectedColumns) {
-                    csvLines.push(util_1.filterArray(row.cells, this.conv.parseRuntime.selectedColumns));
-                }
-                else {
-                    csvLines.push(row.cells);
-                }
-                left = "";
-            }
-            else {
-                left = line + (getEol_1.default(line, this.conv.parseRuntime) || "\n");
-            }
-        }
-        return { rowsCells: csvLines, partial: left };
-    };
-    return RowSplit;
-}());
-exports.RowSplit = RowSplit;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/rowSplit.ts","sources":["/Users/kxiang/work/projects/csv2json/src/rowSplit.ts"],"names":[],"mappings":"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","sourcesContent":["import { CSVParseParam } from \"./Parameters\";\nimport { Converter } from \"./Converter\";\nimport { Fileline } from \"./fileline\";\nimport getEol from \"./getEol\";\nimport { filterArray, trimLeft, trimRight } from \"./util\";\n\nconst defaulDelimiters = [\",\", \"|\", \"\\t\", \";\", \":\"];\nexport class RowSplit {\n  private quote: string;\n  private trim: boolean;\n  private escape: string;\n  private cachedRegExp: { [key: string]: RegExp } = {};\n  private delimiterEmitted = false;\n  private _needEmitDelimiter?: boolean = undefined;\n  private get needEmitDelimiter() {\n    if (this._needEmitDelimiter === undefined) {\n      this._needEmitDelimiter = this.conv.listeners(\"delimiter\").length > 0;\n    }\n    return this._needEmitDelimiter;\n  }\n  constructor(private conv: Converter) {\n    this.quote = conv.parseParam.quote;\n    this.trim = conv.parseParam.trim;\n    this.escape = conv.parseParam.escape;\n  }\n  parse(fileline: Fileline): RowSplitResult {\n    if (fileline.length === 0 || (this.conv.parseParam.ignoreEmpty && fileline.trim().length === 0)) {\n      return { cells: [], closed: true };\n    }\n    const quote = this.quote;\n    const trim = this.trim;\n    const escape = this.escape;\n    if (this.conv.parseRuntime.delimiter instanceof Array || this.conv.parseRuntime.delimiter.toLowerCase() === \"auto\") {\n      this.conv.parseRuntime.delimiter = this.getDelimiter(fileline);\n\n    }\n    if (this.needEmitDelimiter && !this.delimiterEmitted) {\n      this.conv.emit(\"delimiter\", this.conv.parseRuntime.delimiter);\n      this.delimiterEmitted = true;\n    }\n    const delimiter = this.conv.parseRuntime.delimiter;\n    const rowArr = fileline.split(delimiter);\n    if (quote === \"off\") {\n      if (trim) {\n        for (let i = 0; i < rowArr.length; i++) {\n          rowArr[i] = rowArr[i].trim();\n        }\n      }\n      return { cells: rowArr, closed: true };\n    } else {\n      return this.toCSVRow(rowArr, trim, quote, delimiter);\n    }\n\n  }\n  private toCSVRow(rowArr: string[], trim: boolean, quote: string, delimiter: string): RowSplitResult {\n    const row: string[] = [];\n    let inquote = false;\n    let quoteBuff = '';\n    for (let i = 0, rowLen = rowArr.length; i < rowLen; i++) {\n      let e = rowArr[i];\n      if (!inquote && trim) {\n        e = trimLeft(e);\n      }\n      const len = e.length;\n      if (!inquote) {\n        if (len === 2 && e === this.quote + this.quote) {\n          row.push(\"\");\n          continue;\n        } else if (this.isQuoteOpen(e)) { //quote open\n          e = e.substr(1);\n          if (this.isQuoteClose(e)) { //quote close\n            e = e.substring(0, e.lastIndexOf(quote));\n            e = this.escapeQuote(e);\n            row.push(e);\n            continue;\n          } else if (e.indexOf(quote) !== -1) {\n            let count = 0;\n            for (const c of e) {\n              if (c === quote) {\n                count++;\n              }\n            }\n            if (count % 2 === 1) {\n              if (trim) {\n                e = trimRight(e);\n              }\n              row.push(quote + e);\n              continue;\n            }else{\n              inquote = true;\n              quoteBuff += e;\n              continue;  \n            }\n          }\n          else {\n            inquote = true;\n            quoteBuff += e;\n            continue;\n          }\n        } else {\n          if (trim) {\n            e = trimRight(e);\n          }\n          row.push(e);\n          continue;\n        }\n      } else { //previous quote not closed\n        if (this.isQuoteClose(e)) { //close double quote\n          inquote = false;\n          e = e.substr(0, len - 1);\n          quoteBuff += delimiter + e;\n          quoteBuff = this.escapeQuote(quoteBuff);\n          if (trim) {\n            quoteBuff = trimRight(quoteBuff);\n          }\n          row.push(quoteBuff);\n          quoteBuff = \"\";\n        } else {\n          quoteBuff += delimiter + e;\n        }\n      }\n    }\n\n    // if (!inquote && param._needFilterRow) {\n    //   row = filterRow(row, param);\n    // }\n\n    return { cells: row, closed: !inquote };\n  }\n  private getDelimiter(fileline: Fileline): string {\n    let checker;\n    if (this.conv.parseParam.delimiter === \"auto\") {\n      checker = defaulDelimiters;\n    } else if (this.conv.parseParam.delimiter instanceof Array) {\n      checker = this.conv.parseParam.delimiter;\n    } else {\n      return this.conv.parseParam.delimiter;\n    }\n    let count = 0;\n    let rtn = \",\";\n    checker.forEach(function (delim) {\n      const delimCount = fileline.split(delim).length;\n      if (delimCount > count) {\n        rtn = delim;\n        count = delimCount;\n      }\n    });\n    return rtn;\n  }\n  private isQuoteOpen(str: string): boolean {\n    const quote = this.quote;\n    const escape = this.escape;\n    return str[0] === quote && (\n      str[1] !== quote ||\n      str[1] === escape && (str[2] === quote || str.length === 2));\n  }\n  private isQuoteClose(str: string): boolean {\n    const quote = this.quote;\n    const escape = this.escape;\n    if (this.conv.parseParam.trim) {\n      str = trimRight(str);\n    }\n    let count = 0;\n    let idx = str.length - 1;\n    while (str[idx] === quote || str[idx] === escape) {\n      idx--;\n      count++;\n    }\n    return count % 2 !== 0;\n  }\n\n  // private twoDoubleQuote(str: string): string {\n  //   var twoQuote = this.quote + this.quote;\n  //   var curIndex = -1;\n  //   while ((curIndex = str.indexOf(twoQuote, curIndex)) > -1) {\n  //     str = str.substring(0, curIndex) + str.substring(++curIndex);\n  //   }\n  //   return str;\n  // }\n\n\n  private escapeQuote(segment: string): string {\n    const key = \"es|\" + this.quote + \"|\" + this.escape;\n    if (this.cachedRegExp[key] === undefined) {\n      this.cachedRegExp[key] = new RegExp('\\\\' + this.escape + '\\\\' + this.quote, 'g');\n    }\n    const regExp = this.cachedRegExp[key];\n    // console.log(regExp,segment);\n    return segment.replace(regExp, this.quote);\n  }\n  parseMultiLines(lines: Fileline[]): MultipleRowResult {\n    const csvLines: string[][] = [];\n    let left = \"\";\n    while (lines.length) {\n      const line = left + lines.shift();\n      const row = this.parse(line);\n      if (row.cells.length === 0 && this.conv.parseParam.ignoreEmpty) {\n        continue;\n      }\n      if (row.closed || this.conv.parseParam.alwaysSplitAtEOL) {\n        if (this.conv.parseRuntime.selectedColumns) {\n          csvLines.push(filterArray(row.cells, this.conv.parseRuntime.selectedColumns));\n        } else {\n          csvLines.push(row.cells);\n        }\n\n        left = \"\";\n      } else {\n        left = line + (getEol(line, this.conv.parseRuntime) || \"\\n\");\n      }\n    }\n    return { rowsCells: csvLines, partial: left };\n  }\n}\nexport interface MultipleRowResult {\n  rowsCells: string[][];\n  partial: string;\n}\nexport interface RowSplitResult {\n  /**\n   * csv row array. [\"a\",\"b\",\"c\"]\n   */\n  cells: string[],\n  /**\n   * if the passed fileline is a complete row\n   */\n  closed: boolean\n}\n\n"]}

.ts-node/46be5da21...03a456f7a02682d837efbfd48c3882c1725a.js

-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var strip_bom_1 = __importDefault(require("strip-bom"));
-/**
- * For each data chunk coming to parser:
- * 1. append the data to the buffer that is left from last chunk
- * 2. check if utf8 chars being split, if does, stripe the bytes and add to left buffer.
- * 3. stripBom
- */
-function prepareData(chunk, runtime) {
-    var workChunk = concatLeftChunk(chunk, runtime);
-    runtime.csvLineBuffer = undefined;
-    var cleanCSVString = cleanUtf8Split(workChunk, runtime).toString("utf8");
-    if (runtime.started === false) {
-        return strip_bom_1.default(cleanCSVString);
-    }
-    else {
-        return cleanCSVString;
-    }
-}
-exports.prepareData = prepareData;
-/**
- *  append data to buffer that is left form last chunk
- */
-function concatLeftChunk(chunk, runtime) {
-    if (runtime.csvLineBuffer && runtime.csvLineBuffer.length > 0) {
-        return Buffer.concat([runtime.csvLineBuffer, chunk]);
-    }
-    else {
-        return chunk;
-    }
-}
-/**
- * check if utf8 chars being split, if does, stripe the bytes and add to left buffer.
- */
-function cleanUtf8Split(chunk, runtime) {
-    var idx = chunk.length - 1;
-    /**
-     * From Keyang:
-     * The code below is to check if a single utf8 char (which could be multiple bytes) being split.
-     * If the char being split, the buffer from two chunk needs to be concat
-     * check how utf8 being encoded to understand the code below.
-     * If anyone has any better way to do this, please let me know.
-     */
-    if ((chunk[idx] & 1 << 7) != 0) {
-        while ((chunk[idx] & 3 << 6) === 128) {
-            idx--;
-        }
-        idx--;
-    }
-    if (idx != chunk.length - 1) {
-        runtime.csvLineBuffer = chunk.slice(idx + 1);
-        return chunk.slice(0, idx + 1);
-        // var _cb=cb;
-        // var self=this;
-        // cb=function(){
-        //   if (self._csvLineBuffer){
-        //     self._csvLineBuffer=Buffer.concat([bufFromString(self._csvLineBuffer,"utf8"),left]);
-        //   }else{
-        //     self._csvLineBuffer=left;
-        //   }
-        //   _cb();
-        // }
-    }
-    else {
-        return chunk;
-    }
-}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/46be5da21...4e23bc68c04722b69733daf9ab0cba48d2b4.js

-"use strict";
-var Converter_1 = require("./Converter");
-var helper = function (param, options) {
-    return new Converter_1.Converter(param, options);
-};
-helper["Converter"] = Converter_1.Converter;
-module.exports = helper;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9pbmRleC50cyIsInNvdXJjZXMiOlsiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBRUEseUNBQXdDO0FBRXhDLElBQU0sTUFBTSxHQUFHLFVBQVUsS0FBOEIsRUFBRSxPQUEwQjtJQUNqRixPQUFPLElBQUkscUJBQVMsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDdkMsQ0FBQyxDQUFBO0FBRUQsTUFBTSxDQUFDLFdBQVcsQ0FBQyxHQUFHLHFCQUFTLENBQUM7QUFDaEMsaUJBQVEsTUFBTSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHJhbnNmb3JtT3B0aW9ucyB9IGZyb20gXCJzdHJlYW1cIjtcbmltcG9ydCB7IENTVlBhcnNlUGFyYW0gfSBmcm9tIFwiLi9QYXJhbWV0ZXJzXCI7XG5pbXBvcnQgeyBDb252ZXJ0ZXIgfSBmcm9tIFwiLi9Db252ZXJ0ZXJcIjtcblxuY29uc3QgaGVscGVyID0gZnVuY3Rpb24gKHBhcmFtPzogUGFydGlhbDxDU1ZQYXJzZVBhcmFtPiwgb3B0aW9ucz86IFRyYW5zZm9ybU9wdGlvbnMpOiBDb252ZXJ0ZXIge1xuICByZXR1cm4gbmV3IENvbnZlcnRlcihwYXJhbSwgb3B0aW9ucyk7XG59XG5cbmhlbHBlcltcIkNvbnZlcnRlclwiXSA9IENvbnZlcnRlcjtcbmV4cG9ydCA9aGVscGVyOyJdfQ==

.ts-node/46be5da21...ed78373de3210b31ccf65b4aed7731f9e9cd.js

-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var Converter_1 = require("../src/Converter");
-var src_1 = __importDefault(require("../src"));
-var assert = require("assert");
-var fs = require("fs");
-var sandbox = require("sinon").sandbox.create();
-var file = __dirname + "/data/testData";
-var trailCommaData = __dirname + "/data/trailingComma";
-describe("CSV Converter", function () {
-    afterEach(function () {
-        sandbox.restore();
-    });
-    it("should create new instance of csv", function () {
-        var obj = new Converter_1.Converter();
-        assert(obj);
-    });
-    it("should read from a stream", function (done) {
-        var obj = new Converter_1.Converter();
-        var stream = fs.createReadStream(file);
-        obj.then(function (obj) {
-            assert.equal(obj.length, 2);
-            done();
-        });
-        stream.pipe(obj);
-    });
-    it("should call onNext once a row is parsed.", function (done) {
-        var obj = new Converter_1.Converter();
-        var stream = fs.createReadStream(file);
-        var called = false;
-        obj.subscribe(function (resultRow) {
-            assert(resultRow);
-            called = true;
-        });
-        obj.on("done", function () {
-            assert(called);
-            done();
-        });
-        stream.pipe(obj);
-    });
-    it("should emit end_parsed message once it is finished.", function (done) {
-        var obj = new Converter_1.Converter();
-        obj.then(function (result) {
-            assert(result);
-            assert(result.length === 2);
-            assert(result[0].date);
-            assert(result[0].employee);
-            assert(result[0].employee.name);
-            assert(result[0].employee.age);
-            assert(result[0].employee.number);
-            assert(result[0].employee.key.length === 2);
-            assert(result[0].address.length === 2);
-            done();
-        });
-        fs.createReadStream(file).pipe(obj);
-    });
-    it("should handle traling comma gracefully", function (done) {
-        var stream = fs.createReadStream(trailCommaData);
-        var obj = new Converter_1.Converter();
-        obj.then(function (result) {
-            assert(result);
-            assert(result.length > 0);
-            done();
-        });
-        stream.pipe(obj);
-    });
-    it("should handle comma in column which is surrounded by qoutes", function (done) {
-        var testData = __dirname + "/data/dataWithComma";
-        var rs = fs.createReadStream(testData);
-        var obj = new Converter_1.Converter({
-            "quote": "#"
-        });
-        obj.then(function (result) {
-            assert(result[0].col1 === "\"Mini. Sectt");
-            assert.equal(result[3].col2, "125001,fenvkdsf");
-            // console.log(result);
-            done();
-        });
-        rs.pipe(obj);
-    });
-    it("should be able to convert a csv to column array data", function (done) {
-        var columArrData = __dirname + "/data/columnArray";
-        var rs = fs.createReadStream(columArrData);
-        var result = {};
-        var csvConverter = new Converter_1.Converter();
-        //end_parsed will be emitted once parsing finished
-        csvConverter.then(function () {
-            assert(result.TIMESTAMP.length === 5);
-            done();
-        });
-        //record_parsed will be emitted each time a row has been parsed.
-        csvConverter.subscribe(function (resultRow, rowIndex) {
-            for (var key in resultRow) {
-                if (resultRow.hasOwnProperty(key)) {
-                    if (!result[key] || !(result[key] instanceof Array)) {
-                        result[key] = [];
-                    }
-                    result[key][rowIndex] = resultRow[key];
-                }
-            }
-        });
-        rs.pipe(csvConverter);
-    });
-    it("should be able to convert csv string directly", function (done) {
-        var testData = __dirname + "/data/testData";
-        var data = fs.readFileSync(testData).toString();
-        var csvConverter = new Converter_1.Converter();
-        //end_parsed will be emitted once parsing finished
-        csvConverter.then(function (jsonObj) {
-            assert.equal(jsonObj.length, 2);
-        });
-        csvConverter.fromString(data).then(function (jsonObj) {
-            assert(jsonObj.length === 2);
-            done();
-        });
-    });
-    it("should be able to convert csv string with error", function (done) {
-        var testData = __dirname + "/data/dataWithUnclosedQuotes";
-        var data = fs.readFileSync(testData).toString();
-        var csvConverter = new Converter_1.Converter();
-        csvConverter.fromString(data).then(undefined, function (err) {
-            assert(err);
-            assert.equal(err.err, "unclosed_quote");
-            done();
-        });
-    });
-    it("should be able to convert csv string without callback provided", function (done) {
-        var testData = __dirname + "/data/testData";
-        var data = fs.readFileSync(testData).toString();
-        var csvConverter = new Converter_1.Converter();
-        //end_parsed will be emitted once parsing finished
-        csvConverter.then(function (jsonObj) {
-            assert(jsonObj.length === 2);
-            done();
-        });
-        csvConverter.fromString(data);
-    });
-    it("should be able to handle columns with double quotes", function (done) {
-        var testData = __dirname + "/data/dataWithQoutes";
-        var data = fs.readFileSync(testData).toString();
-        var csvConverter = new Converter_1.Converter();
-        csvConverter.fromString(data).then(function (jsonObj) {
-            assert(jsonObj[0].TIMESTAMP === '13954264"22', JSON.stringify(jsonObj[0].TIMESTAMP));
-            assert(jsonObj[1].TIMESTAMP === 'abc, def, ccc', JSON.stringify(jsonObj[1].TIMESTAMP));
-            done();
-        });
-    });
-    it("should be able to handle columns with two double quotes", function (done) {
-        var testData = __dirname + "/data/twodoublequotes";
-        var data = fs.readFileSync(testData).toString();
-        var csvConverter = new Converter_1.Converter();
-        csvConverter.fromString(data).then(function (jsonObj) {
-            assert.equal(jsonObj[0].title, "\"");
-            assert.equal(jsonObj[0].data, "xyabcde");
-            assert.equal(jsonObj[0].uuid, "fejal\"eifa");
-            assert.equal(jsonObj[0].fieldA, "bnej\"\"falkfe");
-            assert.equal(jsonObj[0].fieldB, "\"eisjfes\"");
-            done();
-        });
-    });
-    it("should handle empty csv file", function (done) {
-        var testData = __dirname + "/data/emptyFile";
-        var rs = fs.createReadStream(testData);
-        var csvConverter = new Converter_1.Converter();
-        csvConverter.then(function (jsonObj) {
-            assert(jsonObj.length === 0);
-            done();
-        });
-        rs.pipe(csvConverter);
-    });
-    it("should parse large csv file", function (done) {
-        var testData = __dirname + "/data/large-csv-sample.csv";
-        var rs = fs.createReadStream(testData);
-        var csvConverter = new Converter_1.Converter();
-        var count = 0;
-        csvConverter.subscribe(function () {
-            //console.log(arguments);
-            count++;
-        });
-        csvConverter.then(function () {
-            assert(count === 5290);
-            done();
-        });
-        rs.pipe(csvConverter);
-    });
-    it("should parse data and covert to specific types", function (done) {
-        var testData = __dirname + "/data/dataWithType";
-        var rs = fs.createReadStream(testData);
-        var csvConverter = new Converter_1.Converter({
-            checkType: true,
-            colParser: {
-                "column6": "string",
-                "column7": "string"
-            }
-        });
-        csvConverter.subscribe(function (d) {
-            assert(typeof d.column1 === "number");
-            assert(typeof d.column2 === "string");
-            assert.equal(d["colume4"], "someinvaliddate");
-            assert(d.column5.hello === "world");
-            assert(d.column6 === '{"hello":"world"}');
-            assert(d.column7 === "1234");
-            assert(d.column8 === "abcd");
-            assert(d.column9 === true);
-            assert(d.column10[0] === 23);
-            assert(d.column10[1] === 31);
-            assert(d.column11[0].hello === "world");
-            assert(d["name#!"] === false);
-        });
-        csvConverter.on("done", function () {
-            done();
-        });
-        rs.pipe(csvConverter);
-    });
-    it("should turn off field type check", function (done) {
-        var testData = __dirname + "/data/dataWithType";
-        var rs = fs.createReadStream(testData);
-        var csvConverter = new Converter_1.Converter({
-            checkType: false
-        });
-        csvConverter.subscribe(function (d) {
-            assert(typeof d.column1 === "string");
-            assert(typeof d.column2 === "string");
-            assert(d["column3"] === "2012-01-01");
-            assert(d["colume4"] === "someinvaliddate");
-            assert(d.column5 === '{"hello":"world"}');
-            assert.equal(d["column6"], '{"hello":"world"}');
-            assert(d["column7"] === "1234");
-            assert(d["column8"] === "abcd");
-            assert(d.column9 === "true");
-            assert(d.column10[0] === "23");
-            assert(d.column10[1] === "31");
-            assert(d["name#!"] === 'false');
-        });
-        csvConverter.then(function () {
-            done();
-        });
-        rs.pipe(csvConverter);
-    });
-    it("should emit data event correctly", function (done) {
-        var testData = __dirname + "/data/large-csv-sample.csv";
-        var csvConverter = new Converter_1.Converter({});
-        var count = 0;
-        csvConverter.on("data", function (d) {
-            count++;
-        });
-        csvConverter.on("end", function () {
-            assert.equal(count, 5290);
-            done();
-        });
-        var rs = fs.createReadStream(testData);
-        rs.pipe(csvConverter);
-    });
-    it("should process column with linebreaks", function (done) {
-        var testData = __dirname + "/data/lineBreak";
-        var rs = fs.createReadStream(testData);
-        var csvConverter = new Converter_1.Converter({
-            checkType: true
-        });
-        csvConverter.subscribe(function (d) {
-            assert(d.Period === 13);
-            assert(d["Apparent age"] === "Unknown");
-            done();
-        });
-        rs.pipe(csvConverter);
-    });
-    it("be able to ignore empty columns", function (done) {
-        var testData = __dirname + "/data/dataIgnoreEmpty";
-        var rs = fs.createReadStream(testData);
-        var st = rs.pipe(src_1.default({ ignoreEmpty: true }));
-        st.then(function (res) {
-            var j = res[0];
-            assert(res.length === 3);
-            assert(j.col2.length === 2);
-            assert(j.col2[1] === "d3");
-            assert(j.col4.col3 === undefined);
-            assert(j.col4.col5 === "world");
-            assert(res[1].col1 === "d2");
-            assert(res[2].col1 === "d4");
-            done();
-        });
-    });
-    it("should allow no header", function (done) {
-        var testData = __dirname + "/data/noheadercsv";
-        var rs = fs.createReadStream(testData);
-        var st = rs.pipe(new Converter_1.Converter({ noheader: true }));
-        st.then(function (res) {
-            var j = res[0];
-            assert(res.length === 5);
-            assert(j.field1 === "CC102-PDMI-001");
-            assert(j.field2 === "eClass_5.1.3");
-            done();
-        });
-    });
-    it("should allow customised header", function (done) {
-        var testData = __dirname + "/data/noheadercsv";
-        var rs = fs.createReadStream(testData);
-        var st = rs.pipe(new Converter_1.Converter({
-            noheader: true,
-            headers: ["a", "b"]
-        }));
-        st.then(function (res) {
-            var j = res[0];
-            assert(res.length === 5);
-            assert(j.a === "CC102-PDMI-001");
-            assert(j.b === "eClass_5.1.3");
-            assert(j.field3 === "10/3/2014");
-            done();
-        });
-    });
-    it("should allow customised header to override existing header", function (done) {
-        var testData = __dirname + "/data/complexJSONCSV";
-        var rs = fs.createReadStream(testData);
-        var st = rs.pipe(new Converter_1.Converter({
-            headers: []
-        }));
-        st.then(function (res) {
-            var j = res[0];
-            assert(res.length === 2);
-            assert(j.field1 === "Food Factory");
-            assert(j.field2 === "Oscar");
-            done();
-        });
-    });
-    it("should handle when there is an empty string", function (done) {
-        var testData = __dirname + "/data/dataWithEmptyString";
-        var rs = fs.createReadStream(testData);
-        var st = rs.pipe(new Converter_1.Converter({
-            noheader: true,
-            headers: ["a", "b", "c"],
-            checkType: true
-        }));
-        st.then(function (res) {
-            var j = res[0];
-            // assert(res.length===2);
-            assert(j.a === "green");
-            assert(j.b === 40);
-            assert.equal(j.c, "");
-            done();
-        });
-    });
-    it("should detect eol correctly when first chunk is smaller than header row length", function (done) {
-        var testData = __dirname + "/data/dataNoTrimCRLF";
-        var rs = fs.createReadStream(testData, { highWaterMark: 3 });
-        var st = rs.pipe(new Converter_1.Converter({
-            trim: false
-        }));
-        st.then(function (res) {
-            var j = res[0];
-            assert(res.length === 2);
-            assert(j.name === "joe");
-            assert(j.age === "20");
-            assert.equal(res[1].name, "sam");
-            assert.equal(res[1].age, "30");
-            done();
-        });
-    });
-    it("should detect eol correctly when first chunk ends in middle of CRLF line break", function (done) {
-        var testData = __dirname + "/data/dataNoTrimCRLF";
-        var rs = fs.createReadStream(testData, { highWaterMark: 9 });
-        var st = rs.pipe(new Converter_1.Converter({
-            trim: false
-        }));
-        st.then(function (res) {
-            var j = res[0];
-            assert(res.length === 2);
-            assert(j.name === "joe");
-            assert(j.age === "20");
-            assert.equal(res[1].name, "sam");
-            assert.equal(res[1].age, "30");
-            done();
-        });
-    });
-    it("should emit eol event when line ending is detected as CRLF", function (done) {
-        var testData = __dirname + "/data/dataNoTrimCRLF";
-        var rs = fs.createReadStream(testData);
-        var st = rs.pipe(new Converter_1.Converter());
-        var eolCallback = sandbox.spy(function (eol) {
-            assert.equal(eol, "\r\n");
-        });
-        st.on("eol", eolCallback);
-        st.then(function () {
-            assert.equal(eolCallback.callCount, 1, 'should emit eol event once');
-            done();
-        });
-    });
-    it("should emit eol event when line ending is detected as LF", function (done) {
-        var testData = __dirname + "/data/columnArray";
-        var rs = fs.createReadStream(testData);
-        var st = rs.pipe(new Converter_1.Converter());
-        var eolCallback = sandbox.spy(function (eol) {
-            assert.equal(eol, "\n");
-        });
-        st.on("eol", eolCallback);
-        st.then(function () {
-            assert.equal(eolCallback.callCount, 1, 'should emit eol event once');
-            done();
-        });
-    });
-    it("should remove the Byte Order Mark (BOM) from input", function (done) {
-        var testData = __dirname + "/data/dataNoTrimBOM";
-        var rs = fs.createReadStream(testData);
-        var st = rs.pipe(new Converter_1.Converter({
-            trim: false
-        }));
-        st.then(function (res) {
-            var j = res[0];
-            assert(res.length === 2);
-            assert(j.name === "joe");
-            assert(j.age === "20");
-            done();
-        });
-    });
-});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/test/testCSVConverter.ts","sources":["/Users/kxiang/work/projects/csv2json/test/testCSVConverter.ts"],"names":[],"mappings":"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","sourcesContent":["import {Converter} from \"../src/Converter\";\nimport csv from \"../src\";\nvar assert = require(\"assert\");\nvar fs = require(\"fs\");\nvar sandbox = require(\"sinon\").sandbox.create();\nvar file = __dirname + \"/data/testData\";\nvar trailCommaData = __dirname + \"/data/trailingComma\";\ndescribe(\"CSV Converter\", function () {\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  it(\"should create new instance of csv\", function () {\n    var obj = new Converter();\n    assert(obj);\n  });\n\n  it(\"should read from a stream\", function (done) {\n    var obj = new Converter();\n    var stream = fs.createReadStream(file);\n    obj.then(function (obj) {\n      assert.equal(obj.length, 2);\n      done();\n    });\n    stream.pipe(obj);\n  });\n\n  it(\"should call onNext once a row is parsed.\", function (done) {\n    var obj = new Converter();\n    var stream = fs.createReadStream(file);\n    var called = false;\n    obj.subscribe(function (resultRow) {\n      assert(resultRow);\n      called = true;\n    });\n    obj.on(\"done\", function () {\n      assert(called);\n      done();\n    });\n    stream.pipe(obj);\n  });\n\n  it(\"should emit end_parsed message once it is finished.\", function (done) {\n    var obj = new Converter();\n    obj.then(function (result) {\n      assert(result);\n      assert(result.length === 2);\n      assert(result[0].date);\n      assert(result[0].employee);\n      assert(result[0].employee.name);\n      assert(result[0].employee.age);\n      assert(result[0].employee.number);\n      assert(result[0].employee.key.length === 2);\n      assert(result[0].address.length === 2);\n      done();\n    });\n    fs.createReadStream(file).pipe(obj);\n  });\n\n  it(\"should handle traling comma gracefully\", function (done) {\n    var stream = fs.createReadStream(trailCommaData);\n    var obj = new Converter();\n    obj.then(function (result) {\n      assert(result);\n      assert(result.length > 0);\n      done();\n    });\n    stream.pipe(obj);\n  });\n\n  it(\"should handle comma in column which is surrounded by qoutes\", function (done) {\n    var testData = __dirname + \"/data/dataWithComma\";\n    var rs = fs.createReadStream(testData);\n    var obj = new Converter({\n      \"quote\": \"#\"\n    });\n    obj.then(function (result) {\n      assert(result[0].col1 === \"\\\"Mini. Sectt\");\n      assert.equal(result[3].col2, \"125001,fenvkdsf\");\n      // console.log(result);\n      done();\n    });\n    rs.pipe(obj);\n  });\n\n  it(\"should be able to convert a csv to column array data\", function (done) {\n    var columArrData = __dirname + \"/data/columnArray\";\n    var rs = fs.createReadStream(columArrData);\n    var result:any = {};\n    var csvConverter = new Converter();\n    //end_parsed will be emitted once parsing finished\n    csvConverter.then(function () {\n      assert(result.TIMESTAMP.length === 5);\n      done();\n    });\n\n    //record_parsed will be emitted each time a row has been parsed.\n    csvConverter.subscribe(function (resultRow, rowIndex) {\n      for (var key in resultRow) {\n        if (resultRow.hasOwnProperty(key)) {\n          if (!result[key] || !(result[key] instanceof Array)) {\n            result[key] = [];\n          }\n          result[key][rowIndex] = resultRow[key];\n        }\n      }\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should be able to convert csv string directly\", function (done) {\n    var testData = __dirname + \"/data/testData\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    //end_parsed will be emitted once parsing finished\n    csvConverter.then(function (jsonObj) {\n      assert.equal(jsonObj.length, 2);\n    });\n    csvConverter.fromString(data).then(function (jsonObj) {\n      assert(jsonObj.length === 2);\n      done();\n    });\n  });\n\n  it(\"should be able to convert csv string with error\", function (done) {\n    var testData = __dirname + \"/data/dataWithUnclosedQuotes\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    csvConverter.fromString(data).then(undefined, function (err) {\n      assert(err);\n      assert.equal(err.err, \"unclosed_quote\");\n      done();\n    });\n  });\n\n  it(\"should be able to convert csv string without callback provided\", function (done) {\n    var testData = __dirname + \"/data/testData\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    //end_parsed will be emitted once parsing finished\n    csvConverter.then(function (jsonObj) {\n      assert(jsonObj.length === 2);\n      done();\n    });\n    csvConverter.fromString(data);\n  });\n\n  it(\"should be able to handle columns with double quotes\", function (done) {\n    var testData = __dirname + \"/data/dataWithQoutes\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    csvConverter.fromString(data).then(function (jsonObj) {\n      assert(jsonObj[0].TIMESTAMP === '13954264\"22', JSON.stringify(jsonObj[0].TIMESTAMP));\n\n      assert(jsonObj[1].TIMESTAMP === 'abc, def, ccc', JSON.stringify(jsonObj[1].TIMESTAMP));\n      done();\n    });\n  });\n\n  it(\"should be able to handle columns with two double quotes\", function (done) {\n    var testData = __dirname + \"/data/twodoublequotes\";\n    var data = fs.readFileSync(testData).toString();\n    var csvConverter = new Converter();\n    csvConverter.fromString(data).then(function (jsonObj) {\n      assert.equal(jsonObj[0].title, \"\\\"\");\n      assert.equal(jsonObj[0].data, \"xyabcde\");\n      assert.equal(jsonObj[0].uuid, \"fejal\\\"eifa\");\n      assert.equal(jsonObj[0].fieldA, \"bnej\\\"\\\"falkfe\");\n      assert.equal(jsonObj[0].fieldB, \"\\\"eisjfes\\\"\");\n      done();\n    });\n  });\n\n  it(\"should handle empty csv file\", function (done) {\n    var testData = __dirname + \"/data/emptyFile\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter();\n    csvConverter.then(function (jsonObj) {\n      assert(jsonObj.length === 0);\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should parse large csv file\", function (done) {\n    var testData = __dirname + \"/data/large-csv-sample.csv\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter();\n    var count = 0;\n    csvConverter.subscribe(function () {\n      //console.log(arguments);\n      count++;\n    });\n    csvConverter.then(function () {\n      assert(count === 5290);\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should parse data and covert to specific types\", function (done) {\n    var testData = __dirname + \"/data/dataWithType\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter({\n      checkType: true,\n      colParser: {\n        \"column6\": \"string\",\n        \"column7\": \"string\"\n      }\n    });\n    csvConverter.subscribe(function (d) {\n      assert(typeof d.column1 === \"number\");\n      assert(typeof d.column2 === \"string\");\n      assert.equal(d[\"colume4\"], \"someinvaliddate\");\n      assert(d.column5.hello === \"world\");\n      assert(d.column6 === '{\"hello\":\"world\"}');\n      assert(d.column7 === \"1234\");\n      assert(d.column8 === \"abcd\");\n      assert(d.column9 === true);\n      assert(d.column10[0] === 23);\n      assert(d.column10[1] === 31);\n      assert(d.column11[0].hello === \"world\");\n      assert(d[\"name#!\"] === false);\n    });\n    csvConverter.on(\"done\", function () {\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should turn off field type check\", function (done) {\n    var testData = __dirname + \"/data/dataWithType\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter({\n      checkType: false\n    });\n    csvConverter.subscribe(function (d) {\n      assert(typeof d.column1 === \"string\");\n      assert(typeof d.column2 === \"string\");\n      assert(d[\"column3\"] === \"2012-01-01\");\n      assert(d[\"colume4\"] === \"someinvaliddate\");\n      assert(d.column5 === '{\"hello\":\"world\"}');\n      assert.equal(d[\"column6\"], '{\"hello\":\"world\"}');\n      assert(d[\"column7\"] === \"1234\");\n      assert(d[\"column8\"] === \"abcd\");\n      assert(d.column9 === \"true\");\n      assert(d.column10[0] === \"23\");\n      assert(d.column10[1] === \"31\");\n      assert(d[\"name#!\"] === 'false');\n    });\n    csvConverter.then(function () {\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should emit data event correctly\", function (done) {\n    var testData = __dirname + \"/data/large-csv-sample.csv\";\n\n    var csvConverter = new Converter({\n    });\n    var count = 0;\n    csvConverter.on(\"data\", function (d) {\n      count++;\n    });\n    csvConverter.on(\"end\", function () {\n      assert.equal(count, 5290);\n      done();\n    });\n    var rs = fs.createReadStream(testData);\n    rs.pipe(csvConverter);\n  });\n\n  it(\"should process column with linebreaks\", function (done) {\n    var testData = __dirname + \"/data/lineBreak\";\n    var rs = fs.createReadStream(testData);\n    var csvConverter = new Converter({\n      checkType: true\n    });\n    csvConverter.subscribe(function (d) {\n      assert(d.Period === 13);\n      assert(d[\"Apparent age\"] === \"Unknown\");\n      done();\n    });\n    rs.pipe(csvConverter);\n  });\n\n  it(\"be able to ignore empty columns\", function (done) {\n    var testData = __dirname + \"/data/dataIgnoreEmpty\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(csv({ ignoreEmpty: true }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 3);\n      assert(j.col2.length === 2);\n      assert(j.col2[1] === \"d3\");\n      assert(j.col4.col3 === undefined);\n      assert(j.col4.col5 === \"world\");\n      assert(res[1].col1 === \"d2\");\n      assert(res[2].col1 === \"d4\");\n      done();\n    });\n  });\n\n  it(\"should allow no header\", function (done) {\n    var testData = __dirname + \"/data/noheadercsv\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({ noheader: true }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 5);\n      assert(j.field1 === \"CC102-PDMI-001\");\n      assert(j.field2 === \"eClass_5.1.3\");\n      done();\n    });\n  });\n\n  it(\"should allow customised header\", function (done) {\n    var testData = __dirname + \"/data/noheadercsv\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({\n      noheader: true,\n      headers: [\"a\", \"b\"]\n    }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 5);\n      assert(j.a === \"CC102-PDMI-001\");\n      assert(j.b === \"eClass_5.1.3\");\n      assert(j.field3 === \"10/3/2014\");\n      done();\n    });\n  });\n\n  it(\"should allow customised header to override existing header\", function (done) {\n    var testData = __dirname + \"/data/complexJSONCSV\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({\n      headers: []\n    }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 2);\n      assert(j.field1 === \"Food Factory\");\n      assert(j.field2 === \"Oscar\");\n      done();\n    });\n  });\n\n  it(\"should handle when there is an empty string\", function (done) {\n    var testData = __dirname + \"/data/dataWithEmptyString\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({\n      noheader: true,\n      headers: [\"a\", \"b\", \"c\"],\n      checkType: true\n    }));\n    st.then(function (res) {\n      var j = res[0];\n\n      // assert(res.length===2);\n      assert(j.a === \"green\");\n      assert(j.b === 40);\n      assert.equal(j.c, \"\");\n      done();\n    });\n  });\n\n  it(\"should detect eol correctly when first chunk is smaller than header row length\", function (done) {\n    var testData = __dirname + \"/data/dataNoTrimCRLF\";\n    var rs = fs.createReadStream(testData, { highWaterMark: 3 });\n\n    var st = rs.pipe(new Converter({\n      trim: false\n    }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 2);\n      assert(j.name === \"joe\");\n      assert(j.age === \"20\");\n      assert.equal(res[1].name, \"sam\");\n      assert.equal(res[1].age, \"30\");\n      done();\n    });\n  });\n\n  it(\"should detect eol correctly when first chunk ends in middle of CRLF line break\", function (done) {\n    var testData = __dirname + \"/data/dataNoTrimCRLF\";\n    var rs = fs.createReadStream(testData, { highWaterMark: 9 });\n\n    var st = rs.pipe(new Converter({\n      trim: false\n    }));\n    st.then(function (res) {\n      var j = res[0];\n      assert(res.length === 2);\n      assert(j.name === \"joe\");\n      assert(j.age === \"20\");\n      assert.equal(res[1].name, \"sam\");\n      assert.equal(res[1].age, \"30\");\n      done();\n    });\n  });\n\n  it(\"should emit eol event when line ending is detected as CRLF\", function (done) {\n    var testData = __dirname + \"/data/dataNoTrimCRLF\";\n    var rs = fs.createReadStream(testData);\n\n    var st = rs.pipe(new Converter());\n    var eolCallback = sandbox.spy(function (eol) {\n      assert.equal(eol, \"\\r\\n\");\n    });\n    st.on(\"eol\", eolCallback);\n    st.then(function () {\n      assert.equal(eolCallback.callCount, 1, 'should emit eol event once');\n      done();\n    })\n  });\n\n  it(\"should emit eol event when line ending is detected as LF\", function (done) {\n    var testData = __dirname + \"/data/columnArray\";\n    var rs = fs.createReadStream(testData);\n\n    var st = rs.pipe(new Converter());\n    var eolCallback = sandbox.spy(function (eol) {\n      assert.equal(eol, \"\\n\");\n    });\n    st.on(\"eol\", eolCallback);\n    st.then(function () {\n      assert.equal(eolCallback.callCount, 1, 'should emit eol event once');\n      done();\n    })\n  });\n\n  it(\"should remove the Byte Order Mark (BOM) from input\", function (done) {\n    var testData = __dirname + \"/data/dataNoTrimBOM\";\n    var rs = fs.createReadStream(testData);\n    var st = rs.pipe(new Converter({\n      trim: false\n    }));\n    st.then( function (res) {\n      var j = res[0];\n\n      assert(res.length===2);\n      assert(j.name === \"joe\");\n      assert(j.age === \"20\");\n      done();\n    });\n  });\n});\n"]}

.ts-node/46be5da21...777abbe25614c4f67780bdd3d4f82f7da832.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function bufFromString(str) {
-    var length = Buffer.byteLength(str);
-    var buffer = Buffer.allocUnsafe
-        ? Buffer.allocUnsafe(length)
-        : new Buffer(length);
-    buffer.write(str);
-    return buffer;
-}
-exports.bufFromString = bufFromString;
-function emptyBuffer() {
-    var buffer = Buffer.allocUnsafe
-        ? Buffer.allocUnsafe(0)
-        : new Buffer(0);
-    return buffer;
-}
-exports.emptyBuffer = emptyBuffer;
-function filterArray(arr, filter) {
-    var rtn = [];
-    for (var i = 0; i < arr.length; i++) {
-        if (filter.indexOf(i) > -1) {
-            rtn.push(arr[i]);
-        }
-    }
-    return rtn;
-}
-exports.filterArray = filterArray;
-exports.trimLeft = String.prototype.trimLeft ? function trimLeftNative(str) {
-    return str.trimLeft();
-} : function trimLeftRegExp(str) {
-    return str.replace(/^\s+/, "");
-};
-exports.trimRight = String.prototype.trimRight ? function trimRightNative(str) {
-    return str.trimRight();
-} : function trimRightRegExp(str) {
-    return str.replace(/\s+$/, "");
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/46be5da21...32028330c67b7273b4691bf9739a14f2084c.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function mergeParams(params) {
-    var defaultParam = {
-        delimiter: ',',
-        ignoreColumns: undefined,
-        includeColumns: undefined,
-        quote: '"',
-        trim: true,
-        checkType: false,
-        ignoreEmpty: false,
-        // fork: false,
-        noheader: false,
-        headers: undefined,
-        flatKeys: false,
-        maxRowLength: 0,
-        checkColumn: false,
-        escape: '"',
-        colParser: {},
-        eol: undefined,
-        alwaysSplitAtEOL: false,
-        output: "json"
-    };
-    if (!params) {
-        params = {};
-    }
-    for (var key in params) {
-        if (params.hasOwnProperty(key)) {
-            if (Array.isArray(params[key])) {
-                defaultParam[key] = [].concat(params[key]);
-            }
-            else {
-                defaultParam[key] = params[key];
-            }
-        }
-    }
-    return defaultParam;
-}
-exports.mergeParams = mergeParams;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"/Users/kxiang/work/projects/csv2json/src/Parameters.ts","sources":["/Users/kxiang/work/projects/csv2json/src/Parameters.ts"],"names":[],"mappings":";;AAoFA,qBAA4B,MAA+B;IACzD,IAAM,YAAY,GAAkB;QAClC,SAAS,EAAE,GAAG;QACd,aAAa,EAAE,SAAS;QACxB,cAAc,EAAE,SAAS;QACzB,KAAK,EAAE,GAAG;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,KAAK;QAChB,WAAW,EAAE,KAAK;QAClB,eAAe;QACf,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,SAAS;QAClB,QAAQ,EAAE,KAAK;QACf,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,KAAK;QAClB,MAAM,EAAE,GAAG;QACX,SAAS,EAAE,EAAE;QACb,GAAG,EAAE,SAAS;QACd,gBAAgB,EAAE,KAAK;QACvB,MAAM,EAAE,MAAM;KACf,CAAA;IACD,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,GAAG,EAAE,CAAC;KACb;IACD,KAAK,IAAI,GAAG,IAAI,MAAM,EAAE;QACtB,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;YAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;gBAC9B,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aAC5C;iBAAM;gBACL,YAAY,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;aACjC;SACF;KACF;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AAlCD,kCAkCC","sourcesContent":["export interface CSVParseParam {\n  /**\n   *   delimiter used for seperating columns. Use \"auto\" if delimiter is unknown in advance, in this case, delimiter will be auto-detected (by best attempt). Use an array to give a list of potential delimiters e.g. [\",\",\"|\",\"$\"]. default: \",\"\n   */\n  delimiter: string | string[];\n  /**\n   *  This parameter instructs the parser to ignore columns as specified by the regular expression. Example: /(name|age)/ will ignore columns whose header contains \"name\" or \"age\"\n   */\n  ignoreColumns?: RegExp;\n  /**\n   *  This parameter instructs the parser to include only those columns as specified by the regular expression. Example: /(name|age)/ will parse and include columns whose header contains \"name\" or \"age\"\n   */\n  includeColumns?: RegExp;\n  /**\n   *  If a column contains delimiter, it is able to use quote character to surround the column content. e.g. \"hello, world\" wont be split into two columns while parsing. Set to \"off\" will ignore all quotes. default: \" (double quote)\n   */\n  quote: string;\n  /**\n   *  Indicate if parser trim off spaces surrounding column content. e.g. \" content \" will be trimmed to \"content\". Default: true\n   */\n  trim: boolean;\n  /**\n   *  This parameter turns on and off whether check field type. Default is false. \n   */\n  checkType: boolean;\n  /**\n   *  Ignore the empty value in CSV columns. If a column value is not given, set this to true to skip them. Default: false.\n   */\n  ignoreEmpty: boolean;\n  /**\n   *  Delegate parsing work to another process.\n   */\n  // fork: boolean;\n  /**\n   *  Indicating csv data has no header row and first row is data row. Default is false.\n   */\n  noheader: boolean;\n  /**\n   *  An array to specify the headers of CSV data. If --noheader is false, this value will override CSV header row. Default: null. Example: [\"my field\",\"name\"].\n   */\n  headers?: string[];\n  /**\n   *  Don't interpret dots (.) and square brackets in header fields as nested object or array identifiers at all (treat them like regular characters for JSON field identifiers). Default: false.\n   */\n  flatKeys: boolean;\n  /**\n   *  the max character a csv row could have. 0 means infinite. If max number exceeded, parser will emit \"error\" of \"row_exceed\". if a possibly corrupted csv data provided, give it a number like 65535 so the parser wont consume memory. default: 0\n   */\n  maxRowLength: number;\n  /**\n   *  whether check column number of a row is the same as headers. If column number mismatched headers number, an error of \"mismatched_column\" will be emitted.. default: false\n   */\n  checkColumn: boolean;\n  /**\n   *  escape character used in quoted column. Default is double quote (\") according to RFC4108. Change to back slash (\\) or other chars for your own case.\n   */\n  escape: string;\n  /**\n   *   Allows override parsing logic for a specific column. It accepts a JSON object with fields like: headName: <String | Function> . e.g. {field1:'number'} will use built-in number parser to convert value of the field1 column to number. Another example {\"name\":nameProcessFunc} will use specified function to parse the value.\n   */\n  colParser: {\n    [key: string]: string | CellParser | ColumnParam\n  };\n  /**\n   *  End of line character. If omitted, parser will attempt to retrieve it from the first chunks of CSV data\n   */\n  eol?: string;\n  /**\n   *  Always interpret each line (as defined by eol) as a row. This will prevent eol characters from being used within a row (even inside a quoted field). This ensures that misplaced quotes only break on row, and not all ensuing rows.\n   */\n  alwaysSplitAtEOL: boolean;\n  /**\n   * The format to be converted to. \"json\" (default) -- convert csv to json. \"csv\" -- convert csv to csv row array. \"line\" -- convert csv to csv line string \n   */\n  output: \"json\" | \"csv\" | \"line\";\n}\n\nexport type CellParser = (item: string, head: string, resultRow: any, row: string[], columnIndex: number) => any;\n\nexport interface ColumnParam {\n  flat?: boolean;\n  cellParser?: string | CellParser;\n}\n\nexport function mergeParams(params?: Partial<CSVParseParam>): CSVParseParam {\n  const defaultParam: CSVParseParam = {\n    delimiter: ',',\n    ignoreColumns: undefined,\n    includeColumns: undefined,\n    quote: '\"',\n    trim: true,\n    checkType: false,\n    ignoreEmpty: false,\n    // fork: false,\n    noheader: false,\n    headers: undefined,\n    flatKeys: false,\n    maxRowLength: 0,\n    checkColumn: false,\n    escape: '\"',\n    colParser: {},\n    eol: undefined,\n    alwaysSplitAtEOL: false,\n    output: \"json\"\n  }\n  if (!params) {\n    params = {};\n  }\n  for (let key in params) {\n    if (params.hasOwnProperty(key)) {\n      if (Array.isArray(params[key])) {\n        defaultParam[key] = [].concat(params[key]);\n      } else {\n        defaultParam[key] = params[key];\n      }\n    }\n  }\n  return defaultParam;\n}\n\n"]}

.ts-node/46be5da21...8b891eb80498ee4ab50c99085e120ad44307.js

-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-var CSVError = /** @class */ (function (_super) {
-    __extends(CSVError, _super);
-    function CSVError(err, line, extra) {
-        var _this = _super.call(this, "Error: " + err + ". JSON Line number: " + line + (extra ? " near: " + extra : "")) || this;
-        _this.err = err;
-        _this.line = line;
-        _this.extra = extra;
-        _this.name = "CSV Parse Error";
-        return _this;
-    }
-    CSVError.column_mismatched = function (index, extra) {
-        return new CSVError("column_mismatched", index, extra);
-    };
-    CSVError.unclosed_quote = function (index, extra) {
-        return new CSVError("unclosed_quote", index, extra);
-    };
-    CSVError.fromJSON = function (obj) {
-        return new CSVError(obj.err, obj.line, obj.extra);
-    };
-    CSVError.prototype.toJSON = function () {
-        return {
-            err: this.err,
-            line: this.line,
-            extra: this.extra
-        };
-    };
-    return CSVError;
-}(Error));
-exports.default = CSVError;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/46be5da21...32bd3d2a0b578a3d58bf502142d57979736c.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var Converter_1 = require("../src/Converter");
-var assert = require("assert");
-var fs = require("fs");
-describe("Converter error handling", function () {
-    it("should handle quote not closed", function (done) {
-        var rs = fs.createReadStream(__dirname + "/data/dataWithUnclosedQuotes");
-        var conv = new Converter_1.Converter({});
-        conv.on("error", function (err) {
-            assert(err.err === "unclosed_quote");
-            done();
-        });
-        rs.pipe(conv);
-    });
-    it("should handle column number mismatched error", function (done) {
-        var rs = fs.createReadStream(__dirname + "/data/dataWithMismatchedColumn");
-        var conv = new Converter_1.Converter({
-            checkColumn: true
-        });
-        var tested = false;
-        conv.on("error", function (err) {
-            if (tested === false) {
-                assert(err.err === "column_mismatched");
-                tested = true;
-                // done();
-            }
-        });
-        conv.on('done', function () {
-            assert(tested);
-            done();
-        });
-        rs.pipe(conv);
-    });
-    it("should treat quote not closed as column_mismatched when alwaysSplitAtEOL is true", function (done) {
-        var rs = fs.createReadStream(__dirname + "/data/dataWithUnclosedQuotes");
-        var conv = new Converter_1.Converter({
-            checkColumn: true,
-            alwaysSplitAtEOL: true,
-        });
-        var tested = false;
-        conv.on("error", function (err) {
-            if (tested === false) {
-                assert(err.err === "column_mismatched");
-                tested = true;
-            }
-        });
-        conv.on('done', function () {
-            assert(tested);
-            done();
-        });
-        rs.pipe(conv);
-    });
-});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

.ts-node/46be5da21...115d1ca9f4258e909100787837de7b2c2dde.js

-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [0, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var ProcessorLocal_1 = require("./ProcessorLocal");
-var Converter_1 = require("./Converter");
-var fs_1 = require("fs");
-var path_1 = __importDefault(require("path"));
-var assert_1 = __importDefault(require("assert"));
-var dataDir = path_1.default.join(__dirname, "../test/data/");
-describe("ProcessLocal", function () {
-    it("should process csv chunks and output json", function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var processor, data, lines, line0;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        processor = new ProcessorLocal_1.ProcessorLocal(new Converter_1.Converter());
-                        data = fs_1.readFileSync(dataDir + "/complexJSONCSV");
-                        return [4 /*yield*/, processor.process(data)];
-                    case 1:
-                        lines = _a.sent();
-                        assert_1.default(lines.length === 2);
-                        line0 = lines[0];
-                        assert_1.default.equal(line0.fieldA.title, "Food Factory");
-                        assert_1.default.equal(line0.fieldA.children.length, 2);
-                        assert_1.default.equal(line0.fieldA.children[1].employee[0].name, "Tim");
-                        return [2 /*return*/];
-                }
-            });
-        });
-    });
-    it("should process csv chunks and output csv rows", function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var processor, data, lines;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        processor = new ProcessorLocal_1.ProcessorLocal(new Converter_1.Converter({ output: "line" }));
-                        data = fs_1.readFileSync(dataDir + "/complexJSONCSV");
-                        return [4 /*yield*/, processor.process(data)];
-                    case 1:
-                        lines = _a.sent();
-                        assert_1.default(lines.length === 2);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    });
-    it("should return empty array if preRawHook removed the data", function () {
-        var conv = new Converter_1.Converter();
-        conv.preRawData(function (str) {
-            return "";
-        });
-        var processor = new ProcessorLocal_1.ProcessorLocal(conv);
-        var data = fs_1.readFileSync(dataDir + "/complexJSONCSV");
-        return processor.process(data)
-            .then(function (list) {
-            assert_1.default.equal(list.length, 0);
-        });
-    });
-});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9Qcm9jZXNzb3JMb2NhbC50ZXN0LnRzIiwic291cmNlcyI6WyIvVXNlcnMva3hpYW5nL3dvcmsvcHJvamVjdHMvY3N2Mmpzb24vc3JjL1Byb2Nlc3NvckxvY2FsLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFnRDtBQUNoRCx5Q0FBd0M7QUFFeEMseUJBQWdDO0FBQ2hDLDhDQUF3QjtBQUN4QixrREFBNEI7QUFFNUIsSUFBTSxPQUFPLEdBQUMsY0FBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUMsZUFBZSxDQUFDLENBQUM7QUFDbkQsUUFBUSxDQUFDLGNBQWMsRUFBQztJQUN0QixFQUFFLENBQUUsMkNBQTJDLEVBQUM7Ozs7Ozt3QkFDeEMsU0FBUyxHQUFDLElBQUksK0JBQWMsQ0FBQyxJQUFJLHFCQUFTLEVBQUUsQ0FBQyxDQUFDO3dCQUM5QyxJQUFJLEdBQUMsaUJBQVksQ0FBQyxPQUFPLEdBQUMsaUJBQWlCLENBQUMsQ0FBQzt3QkFDdkMscUJBQU0sU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBQTs7d0JBQW5DLEtBQUssR0FBQyxTQUE2Qjt3QkFDekMsZ0JBQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQyxDQUFDO3dCQUNyQixLQUFLLEdBQUMsS0FBSyxDQUFDLENBQUMsQ0FBZSxDQUFDO3dCQUNuQyxnQkFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBQyxjQUFjLENBQUMsQ0FBQzt3QkFDaEQsZ0JBQU0sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFDLENBQUMsQ0FBQyxDQUFDO3dCQUM3QyxnQkFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFDLEtBQUssQ0FBQyxDQUFDOzs7OztLQUMvRCxDQUFDLENBQUE7SUFDRixFQUFFLENBQUUsK0NBQStDLEVBQUM7Ozs7Ozt3QkFDNUMsU0FBUyxHQUFDLElBQUksK0JBQWMsQ0FBQyxJQUFJLHFCQUFTLENBQUMsRUFBQyxNQUFNLEVBQUMsTUFBTSxFQUFDLENBQUMsQ0FBQyxDQUFDO3dCQUM3RCxJQUFJLEdBQUMsaUJBQVksQ0FBQyxPQUFPLEdBQUMsaUJBQWlCLENBQUMsQ0FBQzt3QkFDdkMscUJBQU0sU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBQTs7d0JBQW5DLEtBQUssR0FBQyxTQUE2Qjt3QkFFekMsZ0JBQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQyxDQUFDOzs7OztLQUM1QixDQUFDLENBQUE7SUFDRixFQUFFLENBQUUsMERBQTBELEVBQUM7UUFDN0QsSUFBTSxJQUFJLEdBQUMsSUFBSSxxQkFBUyxFQUFFLENBQUM7UUFDM0IsSUFBSSxDQUFDLFVBQVUsQ0FBQyxVQUFDLEdBQUc7WUFDbEIsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDLENBQUMsQ0FBQztRQUNILElBQU0sU0FBUyxHQUFDLElBQUksK0JBQWMsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN6QyxJQUFNLElBQUksR0FBQyxpQkFBWSxDQUFDLE9BQU8sR0FBQyxpQkFBaUIsQ0FBQyxDQUFDO1FBQ25ELE9BQU8sU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUM7YUFDN0IsSUFBSSxDQUFDLFVBQUMsSUFBSTtZQUNULGdCQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUMsQ0FBQyxDQUFDLENBQUM7UUFDOUIsQ0FBQyxDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtQcm9jZXNzb3JMb2NhbH0gZnJvbSBcIi4vUHJvY2Vzc29yTG9jYWxcIjtcbmltcG9ydCB7IENvbnZlcnRlciB9IGZyb20gXCIuL0NvbnZlcnRlclwiO1xuaW1wb3J0IFAgZnJvbSBcImJsdWViaXJkXCI7XG5pbXBvcnQge3JlYWRGaWxlU3luY30gZnJvbSBcImZzXCI7XG5pbXBvcnQgcGF0aCBmcm9tIFwicGF0aFwiO1xuaW1wb3J0IGFzc2VydCBmcm9tIFwiYXNzZXJ0XCI7XG5pbXBvcnQgeyBKU09OUmVzdWx0IH0gZnJvbSBcIi4vbGluZVRvSnNvblwiO1xuY29uc3QgZGF0YURpcj1wYXRoLmpvaW4oX19kaXJuYW1lLFwiLi4vdGVzdC9kYXRhL1wiKTtcbmRlc2NyaWJlKFwiUHJvY2Vzc0xvY2FsXCIsKCk9PntcbiAgaXQgKFwic2hvdWxkIHByb2Nlc3MgY3N2IGNodW5rcyBhbmQgb3V0cHV0IGpzb25cIixhc3luYyBmdW5jdGlvbiAoKXtcbiAgICBjb25zdCBwcm9jZXNzb3I9bmV3IFByb2Nlc3NvckxvY2FsKG5ldyBDb252ZXJ0ZXIoKSk7XG4gICAgY29uc3QgZGF0YT1yZWFkRmlsZVN5bmMoZGF0YURpcitcIi9jb21wbGV4SlNPTkNTVlwiKTtcbiAgICBjb25zdCBsaW5lcz1hd2FpdCBwcm9jZXNzb3IucHJvY2VzcyhkYXRhKTtcbiAgICBhc3NlcnQobGluZXMubGVuZ3RoID09PSAyKTtcbiAgICBjb25zdCBsaW5lMD1saW5lc1swXSBhcyBKU09OUmVzdWx0O1xuICAgIGFzc2VydC5lcXVhbChsaW5lMC5maWVsZEEudGl0bGUsXCJGb29kIEZhY3RvcnlcIik7XG4gICAgYXNzZXJ0LmVxdWFsKGxpbmUwLmZpZWxkQS5jaGlsZHJlbi5sZW5ndGgsMik7XG4gICAgYXNzZXJ0LmVxdWFsKGxpbmUwLmZpZWxkQS5jaGlsZHJlblsxXS5lbXBsb3llZVswXS5uYW1lLFwiVGltXCIpO1xuICB9KVxuICBpdCAoXCJzaG91bGQgcHJvY2VzcyBjc3YgY2h1bmtzIGFuZCBvdXRwdXQgY3N2IHJvd3NcIixhc3luYyBmdW5jdGlvbiAoKXtcbiAgICBjb25zdCBwcm9jZXNzb3I9bmV3IFByb2Nlc3NvckxvY2FsKG5ldyBDb252ZXJ0ZXIoe291dHB1dDpcImxpbmVcIn0pKTtcbiAgICBjb25zdCBkYXRhPXJlYWRGaWxlU3luYyhkYXRhRGlyK1wiL2NvbXBsZXhKU09OQ1NWXCIpO1xuICAgIGNvbnN0IGxpbmVzPWF3YWl0IHByb2Nlc3Nvci5wcm9jZXNzKGRhdGEpO1xuICAgIFxuICAgIGFzc2VydChsaW5lcy5sZW5ndGggPT09IDIpO1xuICB9KVxuICBpdCAoXCJzaG91bGQgcmV0dXJuIGVtcHR5IGFycmF5IGlmIHByZVJhd0hvb2sgcmVtb3ZlZCB0aGUgZGF0YVwiLCgpPT57XG4gICAgY29uc3QgY29udj1uZXcgQ29udmVydGVyKCk7XG4gICAgY29udi5wcmVSYXdEYXRhKChzdHIpPT57XG4gICAgICByZXR1cm4gXCJcIjtcbiAgICB9KTtcbiAgICBjb25zdCBwcm9jZXNzb3I9bmV3IFByb2Nlc3NvckxvY2FsKGNvbnYpO1xuICAgIGNvbnN0IGRhdGE9cmVhZEZpbGVTeW5jKGRhdGFEaXIrXCIvY29tcGxleEpTT05DU1ZcIik7XG4gICAgcmV0dXJuIHByb2Nlc3Nvci5wcm9jZXNzKGRhdGEpXG4gICAgLnRoZW4oKGxpc3QpPT57XG4gICAgICBhc3NlcnQuZXF1YWwobGlzdC5sZW5ndGgsMCk7XG4gICAgfSlcbiAgfSlcbn0pXG5cbiJdfQ==

.ts-node/46be5da21...a99b4eb7ee0ec505f5bc404dfb198396e590.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-describe("CSVError", function () {
-    it("should toString()", function () {
-    });
-});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9DU1ZFcnJvci50ZXN0LnRzIiwic291cmNlcyI6WyIvVXNlcnMva3hpYW5nL3dvcmsvcHJvamVjdHMvY3N2Mmpzb24vc3JjL0NTVkVycm9yLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxRQUFRLENBQUMsVUFBVSxFQUFDO0lBQ2xCLEVBQUUsQ0FBRSxtQkFBbUIsRUFBQztJQUN4QixDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IENTVkVycm9yIGZyb20gXCIuL0NTVkVycm9yXCI7XG5pbXBvcnQgYXNzZXJ0IGZyb20gXCJhc3NlcnRcIjtcbmRlc2NyaWJlKFwiQ1NWRXJyb3JcIiwoKT0+e1xuICBpdCAoXCJzaG91bGQgdG9TdHJpbmcoKVwiLCgpPT57XG4gIH0pXG59KSJdfQ==

.ts-node/46be5da21...91dc885e4e64429d73b07dd25f75a49704bb.js

-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var fileline_1 = require("./fileline");
-var Converter_1 = require("./Converter");
-var assert = require("assert");
-describe("fileline function", function () {
-    it("should convert data to multiple lines ", function () {
-        var conv = new Converter_1.Converter();
-        var data = "abcde\nefef";
-        var result = fileline_1.stringToLines(data, conv.parseRuntime);
-        assert.equal(result.lines.length, 1);
-        assert.equal(result.partial, "efef");
-        assert.equal(result.lines[0], "abcde");
-    });
-});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9maWxlbGluZS50ZXN0LnRzIiwic291cmNlcyI6WyIvVXNlcnMva3hpYW5nL3dvcmsvcHJvamVjdHMvY3N2Mmpzb24vc3JjL2ZpbGVsaW5lLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx1Q0FBeUM7QUFFekMseUNBQXdDO0FBQ3hDLElBQUksTUFBTSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUMvQixRQUFRLENBQUMsbUJBQW1CLEVBQUU7SUFDNUIsRUFBRSxDQUFFLHdDQUF3QyxFQUFFO1FBQzVDLElBQU0sSUFBSSxHQUFDLElBQUkscUJBQVMsRUFBRSxDQUFDO1FBQzNCLElBQUksSUFBSSxHQUFHLGFBQWEsQ0FBQztRQUN6QixJQUFJLE1BQU0sR0FBRyx3QkFBYSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDcEQsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQztRQUNyQyxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDckMsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3pDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge3N0cmluZ1RvTGluZXN9IGZyb20gXCIuL2ZpbGVsaW5lXCI7XG5pbXBvcnQgeyBtZXJnZVBhcmFtcyB9IGZyb20gXCIuL1BhcmFtZXRlcnNcIjtcbmltcG9ydCB7IENvbnZlcnRlciB9IGZyb20gXCIuL0NvbnZlcnRlclwiO1xudmFyIGFzc2VydCA9IHJlcXVpcmUoXCJhc3NlcnRcIik7XG5kZXNjcmliZShcImZpbGVsaW5lIGZ1bmN0aW9uXCIsIGZ1bmN0aW9uKCkge1xuICBpdCAoXCJzaG91bGQgY29udmVydCBkYXRhIHRvIG11bHRpcGxlIGxpbmVzIFwiLCBmdW5jdGlvbigpIHtcbiAgICBjb25zdCBjb252PW5ldyBDb252ZXJ0ZXIoKTtcbiAgICB2YXIgZGF0YSA9IFwiYWJjZGVcXG5lZmVmXCI7XG4gICAgdmFyIHJlc3VsdCA9IHN0cmluZ1RvTGluZXMoZGF0YSwgY29udi5wYXJzZVJ1bnRpbWUpO1xuICAgIGFzc2VydC5lcXVhbChyZXN1bHQubGluZXMubGVuZ3RoLCAxKTtcbiAgICBhc3NlcnQuZXF1YWwocmVzdWx0LnBhcnRpYWwsIFwiZWZlZlwiKTtcbiAgICBhc3NlcnQuZXF1YWwocmVzdWx0LmxpbmVzWzBdLCBcImFiY2RlXCIpO1xuICB9KTtcbn0pO1xuIl19

New alerts

Network access

Supply chain risk

This module accesses the network.

Found 1 instance in 1 package

Shell access

Supply chain risk

This module accesses the system shell. Accessing the system shell increases the risk of executing arbitrary code.

Found 1 instance in 1 package

Uses eval

Supply chain risk

Package uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Minified code

Quality

This package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.

Found 1 instance in 1 package

Fixed alerts

Network access

Supply chain risk

This module accesses the network.

Found 1 instance in 1 package

Shell access

Supply chain risk

This module accesses the system shell. Accessing the system shell increases the risk of executing arbitrary code.

Found 1 instance in 1 package

Uses eval

Supply chain risk

Package uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

8685360

2.37%

Number of package files

393

1.03%

Lines of code

12487

3.35%

Number of lines in readme file

681

6.57%

Worsened metrics

Number of low quality alerts

4

33.33%

Number of low supply chain risk alerts

28

3.7%

Number of medium supply chain risk alerts

13

18.18%

No dependency changes