Initial commit

2024-07-15 22:20:13 -04:00
commit 97737ca1ae
@@ -0,0 +1,212 @@
+"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,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
Line truncated
@@ -0,0 +1,32 @@
+"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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
@@ -0,0 +1,522 @@
+"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();
+describe("testCSVConverter2", function () {
+    afterEach(function () {
+        sandbox.restore();
+    });
+    it("should convert from large csv string", function (done) {
+        var csvStr = fs.readFileSync(__dirname + "/data/large-csv-sample.csv", "utf8");
+        var conv = new Converter_1.Converter({});
+        conv.fromString(csvStr).then(function (res) {
+            assert(res.length === 5290);
+            done();
+        });
+    });
+    it("should set eol", function (done) {
+        var rs = fs.createReadStream(__dirname + "/data/large-csv-sample.csv");
+        var conv = new Converter_1.Converter({
+            eol: "\n"
+        });
+        var count = 0;
+        conv.subscribe(function (resultJson, index) {
+            count++;
+            assert(resultJson);
+            // assert(row.length === 2);
+            assert(index >= 0);
+        });
+        conv.on("error", function () {
+            console.log(arguments);
+        });
+        conv.then(function (result) {
+            assert(result);
+            assert(count === 5290);
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should convert tsv String", function (done) {
+        var tsv = __dirname + "/data/dataTsv";
+        var csvStr = fs.readFileSync(tsv, "utf8");
+        var conv = new Converter_1.Converter({
+            delimiter: "\t",
+            "checkType": false
+        });
+        conv.fromString(csvStr).then(function (res) {
+            assert(res);
+            assert.equal(res.length, 200);
+            done();
+        });
+    });
+    it("should allow customised header with nohead csv string.", function (done) {
+        var testData = __dirname + "/data/noheadercsv";
+        var rs = fs.readFileSync(testData, "utf8");
+        var conv = new Converter_1.Converter({
+            noheader: true,
+            headers: ["a", "b", "c", "e", "f", "g"]
+        });
+        conv.fromString(rs).then(function (json) {
+            assert.equal(json[0].field7, 40);
+            assert.equal(json[0].a, "CC102-PDMI-001");
+            done();
+        });
+    });
+    it("should parse fromFile", function (done) {
+        var csvFile = __dirname + "/data/large-csv-sample.csv";
+        var conv = new Converter_1.Converter({});
+        conv.fromFile(csvFile).then(function (res) {
+            assert.equal(res.length, 5290);
+            done();
+        });
+    });
+    it("should fromFile should emit error", function (done) {
+        var csvFile = __dirname + "/data/dataWithUnclosedQuotes";
+        var conv = new Converter_1.Converter({});
+        conv.fromFile(csvFile).then(function (res) {
+            done();
+        }, function (err) {
+            assert(err);
+            done();
+        });
+    });
+    it("should parse no header with dynamic column number", function (done) {
+        var testData = __dirname + "/data/noheaderWithVaryColumnNum";
+        var rs = fs.readFileSync(testData, "utf8");
+        var conv = new Converter_1.Converter({
+            noheader: true
+        });
+        conv.fromString(rs).then(function (json) {
+            assert.equal(json.length, 2);
+            assert.equal(json[1].field4, 7);
+            done();
+        });
+    });
+    it("should parse tabsv data with dynamic columns", function (done) {
+        var testData = __dirname + "/data/tabsv";
+        var rs = fs.readFileSync(testData, "utf8");
+        var conv = new Converter_1.Converter({
+            delimiter: "\t"
+        });
+        conv.fromString(rs).then(function (json) {
+            assert.equal(json[0].Idevise, "");
+            done();
+        });
+    });
+    it("should use first line break as eol", function (done) {
+        var testData = __dirname + "/data/testEol";
+        var conv = new Converter_1.Converter({
+            noheader: true
+        });
+        conv.fromFile(testData).then(function (json) {
+            assert(json);
+            done();
+        });
+    });
+    it("should detect delimiter", function (done) {
+        var testData = __dirname + "/data/dataWithAutoDelimiter";
+        var rs = fs.createReadStream(testData);
+        var conv = new Converter_1.Converter({ delimiter: "auto" });
+        conv.then(function (res) {
+            assert.equal(res[0].col1, "Mini. Sectt:hisar S.O");
+            assert.equal(res[1].col1, "#Mini. Sectt");
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should emit delimiter event", function (done) {
+        var testData = __dirname + "/data/dataWithAutoDelimiter";
+        var rs = fs.createReadStream(testData);
+        var conv = new Converter_1.Converter({ delimiter: "auto" });
+        var delimiterCallback = sandbox.spy(function (delimiter) {
+            assert.equal(delimiter, ":");
+        });
+        conv.on("delimiter", delimiterCallback);
+        conv.then(function () {
+            assert.equal(delimiterCallback.callCount, 1);
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should emit delimiter event when no header", function (done) {
+        var testData = __dirname + "/data/dataWithAutoDelimiter";
+        var rs = fs.createReadStream(testData);
+        var conv = new Converter_1.Converter({ delimiter: "auto", noheader: true });
+        var delimiterCallback = sandbox.spy(function (delimiter) {
+            assert.equal(delimiter, ":");
+        });
+        conv.on("delimiter", delimiterCallback);
+        conv.then(function () {
+            assert.equal(delimiterCallback.callCount, 1);
+            done();
+        });
+        rs.pipe(conv);
+    });
+    // it("should not emit delimiter event when delimiter is specified", function (done) {
+    //   var testData = __dirname + "/data/columnArray";
+    //   var rs = fs.createReadStream(testData);
+    //   var conv = new Converter();
+    //   conv.on("delimiter", function (delimiter) {
+    //     assert.fail("delimiter event should not have been emitted");
+    //   });
+    //   conv.then(function () {
+    //     done();
+    //   });
+    //   rs.pipe(conv);
+    // });
+    it("should stripe out whitespaces if trim is true", function (done) {
+        var testData = __dirname + "/data/dataWithWhiteSpace";
+        var rs = fs.createReadStream(testData);
+        var conv = new Converter_1.Converter({ trim: true });
+        conv.then(function (res) {
+            assert.equal(res[0]["Column 1"], "Column1Row1");
+            assert.equal(res[0]["Column 2"], "Column2Row1");
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should convert triple quotes correctly", function (done) {
+        var testData = __dirname + "/data/dataWithTripleQoutes";
+        var rs = fs.createReadStream(testData);
+        var conv = new Converter_1.Converter({ trim: true });
+        conv.then(function (res) {
+            assert.equal(res[0].Description, "ac, abs, moon");
+            assert.equal(res[1].Model, "Venture \"Extended Edition\"");
+            assert.equal(res[2].Model, "Venture \"Extended Edition, Very Large\"");
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should pre process raw data in the line", function (done) {
+        var testData = __dirname + "/data/quoteTolerant";
+        var rs = fs.createReadStream(testData);
+        var conv = new Converter_1.Converter();
+        conv.preRawData(function (d) {
+            return d.replace('THICK', 'THIN');
+        });
+        conv.then(function (res) {
+            assert(res[0].Description.indexOf('THIN') > -1);
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should pre process by line in the line", function (done) {
+        var testData = __dirname + "/data/quoteTolerant";
+        var rs = fs.createReadStream(testData);
+        var conv = new Converter_1.Converter();
+        conv.preFileLine(function (line, lineNumber) {
+            if (lineNumber === 1) {
+                line = line.replace('THICK', 'THIN');
+            }
+            return line;
+        });
+        conv.then(function (res) {
+            assert(res[0].Description.indexOf('THIN') > -1);
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should support object mode", function (done) {
+        var testData = __dirname + "/data/complexJSONCSV";
+        var rs = fs.createReadStream(testData);
+        var conv = new Converter_1.Converter({}, {
+            objectMode: true
+        });
+        conv.on("data", function (d) {
+            assert(typeof d === "object");
+        });
+        conv.then(function (res) {
+            assert(res);
+            assert(res.length > 0);
+            done();
+        });
+        rs.pipe(conv);
+    });
+    it("should get delimiter automatically if there is no header", function (done) {
+        var test_converter = new Converter_1.Converter({
+            delimiter: 'auto',
+            headers: ['col1', 'col2'],
+            noheader: true,
+            checkColumn: true
+        });
+        var my_data = 'first_val\tsecond_val';
+        test_converter.fromString(my_data).then(function (result) {
+            assert.equal(result.length, 1);
+            assert.equal(result[0].col1, "first_val");
+            assert.equal(result[0].col2, "second_val");
+            done();
+        });
+    });
+    it("should process escape chars", function (done) {
+        var test_converter = new Converter_1.Converter({
+            escape: "\\",
+            checkType: true
+        });
+        var testData = __dirname + "/data/dataWithSlashEscape";
+        var rs = fs.createReadStream(testData);
+        test_converter.then(function (res) {
+            assert.equal(res[0].raw.hello, "world");
+            assert.equal(res[0].raw.test, true);
+            done();
+        });
+        rs.pipe(test_converter);
+    });
+    it("should output ndjson format", function (done) {
+        var conv = new Converter_1.Converter();
+        conv.fromString("a,b,c\n1,2,3\n4,5,6")
+            .on("data", function (d) {
+            d = d.toString();
+            assert.equal(d[d.length - 1], "\n");
+        })
+            .on("done", done);
+    });
+    it("should parse from stream", function (done) {
+        var testData = __dirname + "/data/complexJSONCSV";
+        var rs = fs.createReadStream(testData);
+        src_1.default()
+            .fromStream(rs)
+            .then(function (res) {
+            assert(res);
+            done();
+        });
+    });
+    it("should set output as csv", function (done) {
+        var testData = __dirname + "/data/complexJSONCSV";
+        var rs = fs.createReadStream(testData);
+        var numOfRow = 0;
+        src_1.default({ output: "csv" })
+            .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 transform with subscribe function", function (done) {
+        var testData = __dirname + "/data/complexJSONCSV";
+        var rs = fs.createReadStream(testData);
+        var numOfRow = 0;
+        var numOfJson = 0;
+        src_1.default()
+            .fromStream(rs)
+            .subscribe(function (json, idx) {
+            json.a = "test";
+            assert(idx >= 0);
+        })
+            .on("data", function (d) {
+            var j = JSON.parse(d.toString());
+            assert.equal(j.a, "test");
+        })
+            .on("end", function () {
+            done();
+        });
+    });
+    it("should parse a complex JSON", function (done) {
+        var converter = new Converter_1.Converter({ checkType: true });
+        var r = fs.createReadStream(__dirname + "/data/complexJSONCSV");
+        converter.then(function (res) {
+            assert(res);
+            assert(res.length === 2);
+            assert(res[0].fieldA.title === "Food Factory");
+            assert(res[0].fieldA.children.length === 2);
+            assert(res[0].fieldA.children[0].name === "Oscar");
+            assert(res[0].fieldA.children[0].id === 23);
+            assert(res[0].fieldA.children[1].name === "Tikka");
+            assert.equal(res[0].fieldA.children[1].employee.length, 2);
+            assert(res[0].fieldA.children[1].employee[0].name === "Tim", JSON.stringify(res[0].fieldA.children[1].employee[0]));
+            assert(res[0].fieldA.address.length === 2);
+            assert(res[0].fieldA.address[0] === "3 Lame Road");
+            assert(res[0].fieldA.address[1] === "Grantstown");
+            assert(res[0].description === "A fresh new food factory", res[0].description);
+            done();
+        });
+        r.pipe(converter);
+    });
+    it("should allow flatKey to change parse behaviour", function (done) {
+        var conv = new Converter_1.Converter({
+            flatKeys: true
+        });
+        conv.fromString("a.b,b.d,c.a\n1,2,3\n4,5,6").subscribe(function (d) {
+            assert(d["a.b"]);
+            assert(d["b.d"]);
+            assert(d["c.a"]);
+        })
+            .on("done", done);
+    });
+    it("should allow flat mods to change parse behaviour", function (done) {
+        var conv = new Converter_1.Converter({
+            colParser: {
+                "a.b": {
+                    flat: true
+                }
+            }
+        });
+        conv.fromString("a.b,b.d,c.a\n1,2,3\n4,5,6").subscribe(function (d) {
+            assert(d["a.b"]);
+        })
+            .on("done", 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;
+        src_1.default({}, { 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");
+        src_1.default()
+            .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;
+        src_1.default({
+            ignoreColumns: /TIMESTAMP/
+        })
+            .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) {
+            assert(!j.TIMESTAMP);
+            assert(idx >= 0);
+        })
+            .on("done", function () {
+            assert(headerEmitted);
+            done();
+        });
+    });
+    it("should keep space around comma in csv", function () {
+        var str = "\"Name\",\"Number\"\n    \"John , space\", 1234\n    \"Mr. , space\", 4321\n    ";
+        return src_1.default().fromString(str)
+            .then(function (data) {
+            assert.equal(data[0].Name, "John , space");
+            assert.equal(data[1].Name, "Mr. , space");
+        });
+    });
+    it("should include column", function (done) {
+        var rs = fs.createReadStream(__dirname + "/data/dataWithQoutes");
+        src_1.default({
+            includeColumns: /TIMESTAMP/
+        })
+            .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;
+        src_1.default({
+            headers: headers,
+            includeColumns: /(first|second|third)/,
+        })
+            .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 src_1.default({
+            includeColumns: /(fieldA\.title|description)/,
+        })
+            .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 only call done once", function (done) {
+        var counter = 0;
+        src_1.default()
+            .fromString('"a","b", "c""')
+            .on('done', function () {
+            counter++;
+        });
+        setTimeout(function () {
+            assert.equal(counter, 1);
+            done();
+        }, 100);
+    });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated
@@ -0,0 +1,310 @@
+"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,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
Line truncated
@@ -0,0 +1,43 @@
+"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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3NyYy9QYXJhbWV0ZXJzLnRzIiwic291cmNlcyI6WyIvVXNlcnMva3hpYW5nL3dvcmsvcHJvamVjdHMvY3N2Mmpzb24vc3JjL1BhcmFtZXRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFpR0EscUJBQTRCLE1BQStCO0lBQ3pELElBQU0sWUFBWSxHQUFrQjtRQUNsQyxTQUFTLEVBQUUsR0FBRztRQUNkLGFBQWEsRUFBRSxTQUFTO1FBQ3hCLGNBQWMsRUFBRSxTQUFTO1FBQ3pCLEtBQUssRUFBRSxHQUFHO1FBQ1YsSUFBSSxFQUFFLElBQUk7UUFDVixTQUFTLEVBQUUsS0FBSztRQUNoQixXQUFXLEVBQUUsS0FBSztRQUNsQixlQUFlO1FBQ2YsUUFBUSxFQUFFLEtBQUs7UUFDZixPQUFPLEVBQUUsU0FBUztRQUNsQixRQUFRLEVBQUUsS0FBSztRQUNmLFlBQVksRUFBRSxDQUFDO1FBQ2YsV0FBVyxFQUFFLEtBQUs7UUFDbEIsTUFBTSxFQUFFLEdBQUc7UUFDWCxTQUFTLEVBQUUsRUFBRTtRQUNiLEdBQUcsRUFBRSxTQUFTO1FBQ2QsZ0JBQWdCLEVBQUUsS0FBSztRQUN2QixNQUFNLEVBQUUsTUFBTTtRQUNkLFVBQVUsRUFBRSxLQUFLO1FBQ2pCLGdCQUFnQixFQUFDLE1BQU07UUFDdkIsV0FBVyxFQUFDLElBQUk7S0FDakIsQ0FBQTtJQUNELElBQUksQ0FBQyxNQUFNLEVBQUU7UUFDWCxNQUFNLEdBQUcsRUFBRSxDQUFDO0tBQ2I7SUFDRCxLQUFLLElBQUksR0FBRyxJQUFJLE1BQU0sRUFBRTtRQUN0QixJQUFJLE1BQU0sQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDOUIsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFO2dCQUM5QixZQUFZLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQzthQUM1QztpQkFBTTtnQkFDTCxZQUFZLENBQUMsR0FBRyxDQUFDLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2FBQ2pDO1NBQ0Y7S0FDRjtJQUNELE9BQU8sWUFBWSxDQUFDO0FBQ3RCLENBQUM7QUFyQ0Qsa0NBcUNDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBDU1ZQYXJzZVBhcmFtIHtcbiAgLyoqXG4gICAqICAgZGVsaW1pdGVyIHVzZWQgZm9yIHNlcGVyYXRpbmcgY29sdW1ucy4gVXNlIFwiYXV0b1wiIGlmIGRlbGltaXRlciBpcyB1bmtub3duIGluIGFkdmFuY2UsIGluIHRoaXMgY2FzZSwgZGVsaW1pdGVyIHdpbGwgYmUgYXV0by1kZXRlY3RlZCAoYnkgYmVzdCBhdHRlbXB0KS4gVXNlIGFuIGFycmF5IHRvIGdpdmUgYSBsaXN0IG9mIHBvdGVudGlhbCBkZWxpbWl0ZXJzIGUuZy4gW1wiLFwiLFwifFwiLFwiJFwiXS4gZGVmYXVsdDogXCIsXCJcbiAgICovXG4gIGRlbGltaXRlcjogc3RyaW5nIHwgc3RyaW5nW107XG4gIC8qKlxuICAgKiAgVGhpcyBwYXJhbWV0ZXIgaW5zdHJ1Y3RzIHRoZSBwYXJzZXIgdG8gaWdub3JlIGNvbHVtbnMgYXMgc3BlY2lmaWVkIGJ5IHRoZSByZWd1bGFyIGV4cHJlc3Npb24uIEV4YW1wbGU6IC8obmFtZXxhZ2UpLyB3aWxsIGlnbm9yZSBjb2x1bW5zIHdob3NlIGhlYWRlciBjb250YWlucyBcIm5hbWVcIiBvciBcImFnZVwiXG4gICAqL1xuICBpZ25vcmVDb2x1bW5zPzogUmVnRXhwO1xuICAvKipcbiAgICogIFRoaXMgcGFyYW1ldGVyIGluc3RydWN0cyB0aGUgcGFyc2VyIHRvIGluY2x1ZGUgb25seSB0aG9zZSBjb2x1bW5zIGFzIHNwZWNpZmllZCBieSB0aGUgcmVndWxhciBleHByZXNzaW9uLiBFeGFtcGxlOiAvKG5hbWV8YWdlKS8gd2lsbCBwYXJzZSBhbmQgaW5jbHVkZSBjb2x1bW5zIHdob3NlIGhlYWRlciBjb250YWlucyBcIm5hbWVcIiBvciBcImFnZVwiXG4gICAqL1xuICBpbmNsdWRlQ29sdW1ucz86IFJlZ0V4cDtcbiAgLyoqXG4gICAqICBJZiBhIGNvbHVtbiBjb250YWlucyBkZWxpbWl0ZXIsIGl0IGlzIGFibGUgdG8gdXNlIHF1b3RlIGNoYXJhY3RlciB0byBzdXJyb3VuZCB0aGUgY29sdW1uIGNvbnRlbnQuIGUuZy4gXCJoZWxsbywgd29ybGRcIiB3b250IGJlIHNwbGl0IGludG8gdHdvIGNvbHVtbnMgd2hpbGUgcGFyc2luZy4gU2V0IHRvIFwib2ZmXCIgd2lsbCBpZ25vcmUgYWxsIHF1b3Rlcy4gZGVmYXVsdDogXCIgKGRvdWJsZSBxdW90ZSlcbiAgICovXG4gIHF1b3RlOiBzdHJpbmc7XG4gIC8qKlxuICAgKiAgSW5kaWNhdGUgaWYgcGFyc2VyIHRyaW0gb2ZmIHNwYWNlcyBzdXJyb3VuZGluZyBjb2x1bW4gY29udGVudC4gZS5nLiBcIiBjb250ZW50IFwiIHdpbGwgYmUgdHJpbW1lZCB0byBcImNvbnRlbnRcIi4gRGVmYXVsdDogdHJ1ZVxuICAgKi9cbiAgdHJpbTogYm9vbGVhbjtcbiAgLyoqXG4gICAqICBUaGlzIHBhcmFtZXRlciB0dXJucyBvbiBhbmQgb2ZmIHdoZXRoZXIgY2hlY2sgZmllbGQgdHlwZS4gRGVmYXVsdCBpcyBmYWxzZS4gXG4gICAqL1xuICBjaGVja1R5cGU6IGJvb2xlYW47XG4gIC8qKlxuICAgKiAgSWdub3JlIHRoZSBlbXB0eSB2YWx1ZSBpbiBDU1YgY29sdW1ucy4gSWYgYSBjb2x1bW4gdmFsdWUgaXMgbm90IGdpdmVuLCBzZXQgdGhpcyB0byB0cnVlIHRvIHNraXAgdGhlbS4gRGVmYXVsdDogZmFsc2UuXG4gICAqL1xuICBpZ25vcmVFbXB0eTogYm9vbGVhbjtcbiAgLyoqXG4gICAqICBEZWxlZ2F0ZSBwYXJzaW5nIHdvcmsgdG8gYW5vdGhlciBwcm9jZXNzLlxuICAgKi9cbiAgLy8gZm9yazogYm9vbGVhbjtcbiAgLyoqXG4gICAqICBJbmRpY2F0aW5nIGNzdiBkYXRhIGhhcyBubyBoZWFkZXIgcm93IGFuZCBmaXJzdCByb3cgaXMgZGF0YSByb3cuIERlZmF1bHQgaXMgZmFsc2UuXG4gICAqL1xuICBub2hlYWRlcjogYm9vbGVhbjtcbiAgLyoqXG4gICAqICBBbiBhcnJheSB0byBzcGVjaWZ5IHRoZSBoZWFkZXJzIG9mIENTViBkYXRhLiBJZiAtLW5vaGVhZGVyIGlzIGZhbHNlLCB0aGlzIHZhbHVlIHdpbGwgb3ZlcnJpZGUgQ1NWIGhlYWRlciByb3cuIERlZmF1bHQ6IG51bGwuIEV4YW1wbGU6IFtcIm15IGZpZWxkXCIsXCJuYW1lXCJdLlxuICAgKi9cbiAgaGVhZGVycz86IHN0cmluZ1tdO1xuICAvKipcbiAgICogIERvbid0IGludGVycHJldCBkb3RzICguKSBhbmQgc3F1YXJlIGJyYWNrZXRzIGluIGhlYWRlciBmaWVsZHMgYXMgbmVzdGVkIG9iamVjdCBvciBhcnJheSBpZGVudGlmaWVycyBhdCBhbGwgKHRyZWF0IHRoZW0gbGlrZSByZWd1bGFyIGNoYXJhY3RlcnMgZm9yIEpTT04gZmllbGQgaWRlbnRpZmllcnMpLiBEZWZhdWx0OiBmYWxzZS5cbiAgICovXG4gIGZsYXRLZXlzOiBib29sZWFuO1xuICAvKipcbiAgICogIHRoZSBtYXggY2hhcmFjdGVyIGEgY3N2IHJvdyBjb3VsZCBoYXZlLiAwIG1lYW5zIGluZmluaXRlLiBJZiBtYXggbnVtYmVyIGV4Y2VlZGVkLCBwYXJzZXIgd2lsbCBlbWl0IFwiZXJyb3JcIiBvZiBcInJvd19leGNlZWRcIi4gaWYgYSBwb3NzaWJseSBjb3JydXB0ZWQgY3N2IGRhdGEgcHJvdmlkZWQsIGdpdmUgaXQgYSBudW1iZXIgbGlrZSA2NTUzNSBzbyB0aGUgcGFyc2VyIHdvbnQgY29uc3VtZSBtZW1vcnkuIGRlZmF1bHQ6IDBcbiAgICovXG4gIG1heFJvd0xlbmd0aDogbnVtYmVyO1xuICAvKipcbiAgICogIHdoZXRoZXIgY2hlY2sgY29sdW1uIG51bWJlciBvZiBhIHJvdyBpcyB0aGUgc2FtZSBhcyBoZWFkZXJzLiBJZiBjb2x1bW4gbnVtYmVyIG1pc21hdGNoZWQgaGVhZGVycyBudW1iZXIsIGFuIGVycm9yIG9mIFwibWlzbWF0Y2hlZF9jb2x1bW5cIiB3aWxsIGJ
Line truncated
@@ -0,0 +1,12 @@
+"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=
@@ -0,0 +1,27 @@
+"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==
@@ -0,0 +1,131 @@
+"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,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
Line truncated
@@ -0,0 +1,22 @@
+"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==
@@ -0,0 +1,9 @@
+"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
@@ -0,0 +1,193 @@
+"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,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
Line truncated
@@ -0,0 +1,22 @@
+"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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
@@ -0,0 +1,638 @@
+"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,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
Line truncated
@@ -0,0 +1,223 @@
+"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,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
Line truncated
@@ -0,0 +1,164 @@
+"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,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
Line truncated
@@ -0,0 +1,72 @@
+"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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
@@ -0,0 +1,418 @@
+"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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3Rlc3QvdGVzdENTVkNvbnZlcnRlci50cyIsInNvdXJjZXMiOlsiL1VzZXJzL2t4aWFuZy93b3JrL3Byb2plY3RzL2NzdjJqc29uL3Rlc3QvdGVzdENTVkNvbnZlcnRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDhDQUEyQztBQUMzQywrQ0FBeUI7QUFDekIsSUFBSSxNQUFNLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBQy9CLElBQUksRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUN2QixJQUFJLE9BQU8sR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDO0FBQ2hELElBQUksSUFBSSxHQUFHLFNBQVMsR0FBRyxnQkFBZ0IsQ0FBQztBQUN4QyxJQUFJLGNBQWMsR0FBRyxTQUFTLEdBQUcscUJBQXFCLENBQUM7QUFDdkQsUUFBUSxDQUFDLGVBQWUsRUFBRTtJQUN4QixTQUFTLENBQUM7UUFDUixPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDcEIsQ0FBQyxDQUFDLENBQUM7SUFFSCxFQUFFLENBQUMsbUNBQW1DLEVBQUU7UUFDdEMsSUFBSSxHQUFHLEdBQUcsSUFBSSxxQkFBUyxFQUFFLENBQUM7UUFDMUIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2QsQ0FBQyxDQUFDLENBQUM7SUFFSCxFQUFFLENBQUMsMkJBQTJCLEVBQUUsVUFBVSxJQUFJO1FBQzVDLElBQUksR0FBRyxHQUFHLElBQUkscUJBQVMsRUFBRSxDQUFDO1FBQzFCLElBQUksTUFBTSxHQUFHLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN2QyxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsR0FBRztZQUNwQixNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUM7WUFDNUIsSUFBSSxFQUFFLENBQUM7UUFDVCxDQUFDLENBQUMsQ0FBQztRQUNILE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbkIsQ0FBQyxDQUFDLENBQUM7SUFFSCxFQUFFLENBQUMsMENBQTBDLEVBQUUsVUFBVSxJQUFJO1FBQzNELElBQUksR0FBRyxHQUFHLElBQUkscUJBQVMsRUFBRSxDQUFDO1FBQzFCLElBQUksTUFBTSxHQUFHLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN2QyxJQUFJLE1BQU0sR0FBRyxLQUFLLENBQUM7UUFDbkIsR0FBRyxDQUFDLFNBQVMsQ0FBQyxVQUFVLFNBQVM7WUFDL0IsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQ2xCLE1BQU0sR0FBRyxJQUFJLENBQUM7UUFDaEIsQ0FBQyxDQUFDLENBQUM7UUFDSCxHQUFHLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRTtZQUNiLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUNmLElBQUksRUFBRSxDQUFDO1FBQ1QsQ0FBQyxDQUFDLENBQUM7UUFDSCxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ25CLENBQUMsQ0FBQyxDQUFDO0lBRUgsRUFBRSxDQUFDLHFEQUFxRCxFQUFFLFVBQVUsSUFBSTtRQUN0RSxJQUFJLEdBQUcsR0FBRyxJQUFJLHFCQUFTLEVBQUUsQ0FBQztRQUMxQixHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsTUFBTTtZQUN2QixNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDZixNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sS0FBSyxDQUFDLENBQUMsQ0FBQztZQUM1QixNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3ZCLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUM7WUFDM0IsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDaEMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDL0IsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDbEMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLE1BQU0sS0FBSyxDQUFDLENBQUMsQ0FBQztZQUM1QyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNLEtBQUssQ0FBQyxDQUFDLENBQUM7WUFDdkMsSUFBSSxFQUFFLENBQUM7UUFDVCxDQUFDLENBQUMsQ0FBQztRQUNILEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDdEMsQ0FBQyxDQUFDLENBQUM7SUFFSCxFQUFFLENBQUMsd0NBQXdDLEVBQUUsVUFBVSxJQUFJO1FBQ3pELElBQUksTUFBTSxHQUFHLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUNqRCxJQUFJLEdBQUcsR0FBRyxJQUFJLHFCQUFTLEVBQUUsQ0FBQztRQUMxQixHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsTUFBTTtZQUN2QixNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDZixNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztZQUMxQixJQUFJLEVBQUUsQ0FBQztRQUNULENBQUMsQ0FBQyxDQUFDO1FBQ0gsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNuQixDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyw2REFBNkQsRUFBRSxVQUFVLElBQUk7UUFDOUUsSUFBSSxRQUFRLEdBQUcsU0FBUyxHQUFHLHFCQUFxQixDQUFDO1FBQ2pELElBQUksRUFBRSxHQUFHLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUN2QyxJQUFJLEdBQUcsR0FBRyxJQUFJLHFCQUFTLENBQUM7WUFDdEIsT0FBTyxFQUFFLEdBQUc7U0FDYixDQUFDLENBQUM7UUFDSCxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsTUFBTTtZQUN2QixNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxlQUFlLENBQUMsQ0FBQztZQUMzQyxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsaUJBQWlCLENBQUMsQ0FBQztZQUNoRCx1QkFBdUI7WUFDdkIsSUFBSSxFQUFFLENBQUM7UUFDVCxDQUFDLENBQUMsQ0FBQztRQUNILEVBQUUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDZixDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyxzREFBc0QsRUFBRSxVQUFVLElBQUk7UUFDdkUsSUFBSSxZQUFZLEdBQUcsU0FBUyxHQUFHLG1CQUFtQixDQUFDO1FBQ25ELElBQUksRUFBRSxHQUFHLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUMzQyxJQUFJLE1BQU0sR0FBTyxFQUFFLENBQUM7UUFDcEIsSUFBSSxZQUFZLEdBQUcsSUFBSSxxQkFBUyxFQUFFLENBQUM7UUFDbkMsa0RBQWtEO1FBQ2xELFlBQVksQ0FBQyxJQUFJLENBQUM7WUFDaEIsTUFBTSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQyxDQUFDO1lBQ3RDLElBQUksRUFBRSxDQUFDO1FBQ1QsQ0FBQyxDQUFDLENBQUM7UUFFSCxnRUFBZ0U7UUFDaEUsWUFBWSxDQUFDLFNBQVMsQ0FBQyxVQUFVLFNBQVMsRUFBRSxRQUFRO1lBQ2xELEtBQUssSUFBSSxHQUFHLElBQUksU0FBUyxFQUFFO2dCQUN6QixJQUFJLFNBQVMsQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLEVBQUU7b0JBQ2pDLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsWUFBWSxLQUFLLENBQUMsRUFBRTt
Line truncated
@@ -0,0 +1,39 @@
+"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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
@@ -0,0 +1,342 @@
+"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,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
Line truncated
@@ -0,0 +1,42 @@
+"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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
@@ -0,0 +1,55 @@
+"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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
@@ -0,0 +1,99 @@
+"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,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
@@ -0,0 +1,7 @@
+"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==
@@ -0,0 +1,16 @@
+"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